Autoboxing
Changes to the language specification for Java 5.0 added implicit conversion of primitive values to their corresponding wrapper objects and vice versa. Previously, Java versions required that primitive values be wrapped in objects before they could be used with collections or other methods that operate in a general way on any java.lang.Object. Although a similar requirement remains in Java 5.0 and later, the compiler will handle wrapping and unwrapping primitive values automatically. Sun calls this "Autoboxing." Similar to the "+" operator with Strings, Autoboxing's ease of development comes at the expense of extra memory allocations under the hood. Autoboxing is best tested for performance in an isolated example, even though it is typically used with collections or the reflection API.
Example 1 executes a method call and field assignment 100,000,000 times using only primitive values and using Autoboxing and unboxing. The compiler creates new java.lang.Integer objects for each primitive int value passed to the autobox method. The primitive value is then extracted from the java.lang.Integer object and assigned to the value field. Java 5.0 executes this example in 840 milliseconds and 11,670 milliseconds for primitive values and autoboxed values, respectively. Java SE 6 executes in 530 milliseconds and 10,900 milliseconds, respectively. The overhead of Autoboxing is more than a full order of magnitude.
// public field to prevent compiler optimizations
public static int value;
public static void autobox (Integer i) { value = i; }
public static void primitive (int i) { value = i; }
public static void main(String[] args) {
for (int i = 0; i < 100000000; i++)
primitive (i);
for (int i = 0; i < 100000000; i++)
autobox (i);
}
Sun's solution to the performance overhead of Autoboxing relies on the old trade-off between memory and speed. Autoboxed values are frequently cached and reused. This is safe because wrapper objects, such as java.lang.Integer, are immutable and can be reused without fear of the wrapped value changing. The performance improvement from caching is seen when the example is changed to pass a constant 7 to the autobox method instead of variable i. Executing with a constant value consumes approximately 6 seconds for both Java 5.0 and Java SE 6.
An implementation that avoids Autoboxing is far more efficient, even with the caching optimization in place. Nevertheless, Autoboxing is still a tempting addition to Java. It eliminates extra coding and, if only executed a few times, does not affect performance. Autoboxing should be avoided for processing large volumes of data. For example, it is beneficial to re-implement a hash map using int primitive values as keys instead of using java.lang.HashMap<Integer,Object> when processing millions of int values. Autoboxing is one more nice addition to the Java language in Version 5.0 to ease development by writing less code—as long as you are aware of its hidden performance overhead.
