Avoid the Object.getClass() Method
Avoid using the Object.getClass() method, because it is not efficient and it produces garbage (the Class object) that is never collected. Also avoid using the example.class literal. Behind the scenes, this generates Class.forName(“Example”).
Writing Efficient Loops
You should always factor loop invariant code out of a loop, as in the following example:
for(int i = 0; i < > ...
}
This code results in vector.size() getting called each time through the loop, which is inefficient. If your container is likely to have more than one element, it is much faster to assign the size to a local variable. In addition, this example using pre-increment (++i) results in smaller code than post-increment (i++). The optimized code appears below:
int size = vector.size();for(int i = 0; i < style="">
...
}
Alternatively, if the order in which you iterate over items is not important, you can iterate backward. Iterating backward avoids the extra local on the stack, and the comparison is also faster, as the following example illustrates:
for(int i = vector.size() - 1; i >= 0; --i) {
...
}
Optimizing Subexpressions If you ever use the same expression twice, do not rely on the compiler to optimize it for you. Use a local variable, as in the following example:
one(i + 1); two(i + 1); // Avoid
int tmp = i + 1;
one(tmp);
two(tmp); // Prefer
Avoid java.util.Enumeration
Avoid using java.util.Enumeration unless you are using it to hide data (in other words, returning an Enumeration of data rather than the data itself). The following example shows a typical use of an Enumeration:
for (Enumeration e = v.elements(); e.hasMoreElements();) { o = e.nextElement();
...
}
Asking a vector or hash table for an Enumeration object creates unnecessary garbage and is slow. Instead, you can iterate over the elements yourself, as in this example:
for(int i = v.size() - 1; i >=0; --i) { o = v.elementAt(i);
...
}
If the vector might be modified by another thread, you must synchronize the iteration:
synchronized(v) { for(int i = v.size() - 1; i >=0; --i) { o = v.elementAt(i);
...
}
}
In Java 2 Platform, Standard Edition (J2SE), you would use an Iterator for this, but Iterators are not available in Java 2 Platform, Micro Edition (J2ME).
Returning null
If you are writing a public method that returns an object, it should never return null unless the following occurs:
- a null is expected during normal program operation.
- the javadoc @return parameter states that null is a possible return value.
If a null is not normally expected, then the method should throw an appropriate exception, which forces the caller to deal with the problem explicitly. The caller is not expected to check for a null return value, unless the documentation specifies otherwise.
Passing null into Methods
Do not pass null parameters into an API method unless the API Reference documentation explicitly states that the method supports them.
Passing null into a Constructor
To avoid ambiguity when passing a null into a constructor, you should use this form:
new someObject ((Object)null);
A class can have two or more constructors, such as SomeObject(String) and SomeObject(Object), where passing in a null does not identify which constructor to use. As a result, the compiler reports an error. Not all supported constructors necessarily appear in the API Reference documentation, because some constructors are for internal use only. By casting the null to the appropriate object, you indicate precisely which constructor the compiler should use. This practice also ensures forward compatibility if later releases of the API add new constructors.
Optimizing Division Operations
Division operations are slow on the BlackBerry Wireless Handheld because its processor does not have a hardware divide instruction. When you write code that divides a positive number by two, you should use “shift right by one” instead. The following example illustrates this:
midpoint = width / 2; //avoid this
int = width >> 1; //prefer this
This does not work for negative values. Only use “shift right” (>>) when you know you are dealing with a positive value. It does not work for negative values.
Managing Garbage Collection
Avoid calling System.gc() to perform garbage collection. On a full handheld, this could take two seconds. Let the virtual machine (VM) collect garbage automatically.
Casting Using instanceof
It is more efficient to use instanceof instead of classCastException to evaluate whether a cast succeeds. Here is an example of using a try/catch block to catch the classCastException:
try { (String)x.whatever();
} catch(ClassCastException e) { // something else
}
Alternatively, you can use instanceof operator:
if(x instanceof String) { (String)x.whatever();
} else { // something else
}
Using instanceof is faster. The only time you should use the try/catch block is when the failure of the cast is an exceptional circumstance. The BlackBerry Java Development Environment (JDE) compiler and the VM are optimized to perform only one class check in the first block of code. This is true of any code in which the cast is run immediately following a branch determined by an instanceof check. Always perform the cast immediately after the branch so that the optimization can be performed.
Using Longs for Unique Identifiers
You should use longs rather than strings for unique constants, such as globally unique identifiers (GUIDs), hash table keys, and state/context identifiers. So that unique identifiers remain unique across all third-party application developers, you should use randomly generated keys based on a hash of some string. In the input string, you should include enough information to make it unique.
