Some context is required to fully understand the main reason behind this. Primitives versus classes Primitive variables in Java contain values an integer, a double-precision floating point binary number, etc. Because these values may have different lengths , the variables containing them may also have different lengths consider float versus double. On the other hand, class variables contain references to instances.

Author:Dousar Megis
Country:Trinidad & Tobago
Language:English (Spanish)
Published (Last):2 March 2017
PDF File Size:2.84 Mb
ePub File Size:9.25 Mb
Price:Free* [*Free Regsitration Required]

Autoboxing What is Autoboxing? Autoboxing is a feature of the Java language introduced in Java 1. When a Java compiler makes an automatic conversion between the primitive types and their corresponding object wrapper class, it is called autoboxing.

Why Do We Need Autoboxing? A primitive type cannot be put into a collection as collections can only hold object references. So as to put a primitive type to collections a programmer would have to always box a primitive type and put into collections. This would be a pain and was so until java 1.

The autoboxing and unboxing automates this and hence makes the code easier to read and less painful for developers to write. Pitfalls of Autoboxing Performance Autoboxing does create objects which are not clearly visible in the code.

So when autoboxing occurs performance suffers. An Integer is not a substitute for an int; autoboxing and unboxing blur the distinction between primitive types and reference types, but they do not eliminate it.

Unexpected Behavior Confused Equals Autoboxing has brought with itself a lot of things that just are not obvious to a programmer. What would be the output of below code?

And 2L was boxed to Long and hence returned true. Here is simple example that demonstrates the caching of int: System.

Ambiguous Method Calls What would be the result of below code? Here we handle it in a way that accepts that Boolean has 3 possible values, null, true or false. I usually document the behavior of the method for all three case in the Javadocs. Like This Article? Read More From DZone.



Autoboxing and Unboxing Autoboxing is the automatic conversion that the Java compiler makes between the primitive types and their corresponding object wrapper classes. For example, converting an int to an Integer, a double to a Double, and so on. If the conversion goes the other way, this is called unboxing. If you are not yet familiar with the syntax of generics, see the Generics Updated lesson. Because li is a list of Integer objects, not a list of int values, you may wonder why the Java compiler does not issue a compile-time error. The compiler does not generate an error because it creates an Integer object from i and adds the object to li. The Java compiler applies autoboxing when a primitive value is: Passed as a parameter to a method that expects an object of the corresponding wrapper class.


Autoboxing in Java



Autoboxing and Unboxing in Java



Autoboxing and Its Pitfalls


Related Articles