Avoid Creating Objects
Object creation is never free. A generational GC with per-thread allocation
pools for temporary objects can make allocation cheaper, but allocating memory
is always more expensive than not allocating memory.
If you allocate objects in a user interface loop, you will force a periodic
garbage collection, creating little "hiccups" in the user experience.
Thus, you should avoid creating object instances you don't need to. Some
examples of things that can help:
- When extracting strings from a set of input data, try
to return a substring of the original data, instead of creating a copy.
You will create a new String object, but it will share the char
with the data.
- If you have a method returning a string, and you know that its result
will always be appended to a StringBuffer anyway, change your signature
and implementation so that the function does the append directly,
instead of creating a short-lived temporary object.
A somewhat more radical idea is to slice up multidimensional arrays into parallel
single one-dimension arrays:
- An array of ints is a much better than an array of Integers,
but this also generalizes to the fact that two parallel arrays of ints
are also a lot more efficient than an array of (int,int)
objects. The same goes for any combination of primitive types.
- If you need to implement a container that stores tuples of (Foo,Bar)
objects, try to remember that two parallel Foo and Bar arrays are
generally much better than a single array of custom (Foo,Bar) objects.
(The exception to this, of course, is when you're designing an API for
other code to access; in those cases, it's usually better to trade
correct API design for a small hit in speed. But in your own internal
code, you should try and be as efficient as possible.)
Generally speaking, avoid creating short-term temporary objects if you
can. Fewer objects created mean less-frequent garbage collection, which has
a direct impact on user experience.