RSS Feed
Twitter
Orkut
3. Avoid creating unnecessary objects
Reuse a single object instead of creating a functionally equivalent object each time is needed.
• Reuse immutable objects, such as String objects
Avoid statements like String s = new String("abc") as this will create a copy of the String object “abc” every time it is executed. Instead, use String s = "abc";
• Beware about the performance of string concatenation: when two strings are concatenated, a new String object is allocated and the contents of both strings are copied into the new String object. Do not use string concatenation to combine more than a few strings (as the time required is quadratic to the number of strings to combine). As an alternative:
Use the StringBuilder (which replaces StringBuffer in release 1.5) or
Use a character array or
Process the strings one at a time instead of combining them
Note: StringBuilder objects are like String objects, except that they can be modified. Internally, these objects are treated like variable-length arrays that contain a sequence of characters.
• Prefer static factory methods to constructors in classes that provide both; for example, the static factory method Boolean.valueOf(String) is preferable to the constructor Boolean(String) which always creates a new object.
Boolean b = Boolean.valueOf("abc"); //good
Boolean b = new Boolean ("abc"); //bad
• Prefer primitive types to boxed primitives & watch for unintentional autoboxing
public static void main(String[] args) {
Long sum =0L;
for (long i=0; i<=Integer.MAX_VALUE; i++)
sum = sum + i;
System.out.println(sum);
}
// a new object of type Long is created each time the long i is added to the Long sum (autoboxing); sum should be declared of type long (primitive type)
• Prefer multiple parallel one-dimensional arrays to one multi-dimensional array (e.g., multiple parallel arrays of ints are a lot more efficient than an array of (int,int) objects)
• Avoid creating short-lifetime objects to avoid frequent garbage collection
If you have a method returning a string, and you know that its result will always be appended to a StringBuilder anyway, change your method so that it does the append directly, instead of creating a short-lived temporary object.
String m1()
{
String s1 = …;
… return s1;
}
… StringBuilder sb = new StringBuilder();
sb.append(m1());
void m1(StringBuilder sb)
{
String s1 = …;
… sb.append(s1);
}
… StringBuilder sb = new StringBuilder();
m1(sb);
Avoid creating objects in a user interface loop, as it will force a periodic garbage collection, creating little "hiccups" in the user experience.
class MyFirstView extends View
{
protected void onDraw(Canvas canvas)
{
Object obj1;
for (int i=0; i<1000; obj1 =" new" start =" start;" end =" end;">0)
throw new IllegalArgumentException (start+" after"+end);
}
public Date start() {return start;}
public Date end() {return end;}
}
The above class appears to be immutable and to enforce the constraint that the end date follows the start date. However it can be broken by exploiting the fact that the Date is mutable.
Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
end.setYear(78); //Modifies the state of p
The solution is to make defensive copies of each mutable parameter in the constructor. Note that defensive copies are made before checking the validity of the parameters, and the validity check is performed on copies rather than on the originals. This is necessary to protect the class against changes to the parameters from another thread, between the time the parameters are checked and the time they are copied.
public Period(Date start, Date end) {
this.start = new Date(start.getTime());
this.end = new Date(end.getTime());
if (start.compareTo(end) >0)
throw new IllegalArgumentException (start+" after"+end);
}
However, the internal state of p can still be modified through the accessors.
p.end().setYear(78); //Modifies the state of p
The solution is to make the accessors return defensive copies of the mutable internal fields.
public Date start()
{
return new Date(start.getTime());
}
public Date end()
{
return new Date(end.getTime());
}
Reuse a single object instead of creating a functionally equivalent object each time is needed.
• Reuse immutable objects, such as String objects
Avoid statements like String s = new String("abc") as this will create a copy of the String object “abc” every time it is executed. Instead, use String s = "abc";
• Beware about the performance of string concatenation: when two strings are concatenated, a new String object is allocated and the contents of both strings are copied into the new String object. Do not use string concatenation to combine more than a few strings (as the time required is quadratic to the number of strings to combine). As an alternative:
Use the StringBuilder (which replaces StringBuffer in release 1.5) or
Use a character array or
Process the strings one at a time instead of combining them
Note: StringBuilder objects are like String objects, except that they can be modified. Internally, these objects are treated like variable-length arrays that contain a sequence of characters.
• Prefer static factory methods to constructors in classes that provide both; for example, the static factory method Boolean.valueOf(String) is preferable to the constructor Boolean(String) which always creates a new object.
Boolean b = Boolean.valueOf("abc"); //good
Boolean b = new Boolean ("abc"); //bad
• Prefer primitive types to boxed primitives & watch for unintentional autoboxing
public static void main(String[] args) {
Long sum =0L;
for (long i=0; i<=Integer.MAX_VALUE; i++)
sum = sum + i;
System.out.println(sum);
}
// a new object of type Long is created each time the long i is added to the Long sum (autoboxing); sum should be declared of type long (primitive type)
• Prefer multiple parallel one-dimensional arrays to one multi-dimensional array (e.g., multiple parallel arrays of ints are a lot more efficient than an array of (int,int) objects)
• Avoid creating short-lifetime objects to avoid frequent garbage collection
If you have a method returning a string, and you know that its result will always be appended to a StringBuilder anyway, change your method so that it does the append directly, instead of creating a short-lived temporary object.
String m1()
{
String s1 = …;
… return s1;
}
… StringBuilder sb = new StringBuilder();
sb.append(m1());
void m1(StringBuilder sb)
{
String s1 = …;
… sb.append(s1);
}
… StringBuilder sb = new StringBuilder();
m1(sb);
Avoid creating objects in a user interface loop, as it will force a periodic garbage collection, creating little "hiccups" in the user experience.
class MyFirstView extends View
{
protected void onDraw(Canvas canvas)
{
Object obj1;
for (int i=0; i<1000; obj1 =" new" start =" start;" end =" end;">0)
throw new IllegalArgumentException (start+" after"+end);
}
public Date start() {return start;}
public Date end() {return end;}
}
The above class appears to be immutable and to enforce the constraint that the end date follows the start date. However it can be broken by exploiting the fact that the Date is mutable.
Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
end.setYear(78); //Modifies the state of p
The solution is to make defensive copies of each mutable parameter in the constructor. Note that defensive copies are made before checking the validity of the parameters, and the validity check is performed on copies rather than on the originals. This is necessary to protect the class against changes to the parameters from another thread, between the time the parameters are checked and the time they are copied.
public Period(Date start, Date end) {
this.start = new Date(start.getTime());
this.end = new Date(end.getTime());
if (start.compareTo(end) >0)
throw new IllegalArgumentException (start+" after"+end);
}
However, the internal state of p can still be modified through the accessors.
p.end().setYear(78); //Modifies the state of p
The solution is to make the accessors return defensive copies of the mutable internal fields.
public Date start()
{
return new Date(start.getTime());
}
public Date end()
{
return new Date(end.getTime());
}
