Naruto Biju Mode Naruto Biju Mode - 23 days ago 9
Java Question

How java auto boxing/unboxing works?

Since JDK 5.0, auto boxing/unboxing was introduced in java, the trick is simple and helpful, but when i started testing different conversions between wrapper classes and primitive types, i get really confused how the concept of auto boxing works in java, for example:

Boxing

int intValue = 0;
Integer intObject = intValue;
byte byteValue = 0;
intObject = byteValue; // ==> Error


After trying different cases (
short
,
long
,
float
,
double
), the only case which is accepted by the compiler is when the type of the value on the right of affectation operator is
int
.
When i looked inside the source of
Integer.class
i found that it implements only one constructor with
int
parameter.

So my conclusion is that the concept of auto boxing is based on constructor implemented in the wrapper class. I want to know if this conclusion is true or there is another concept used by auto boxing?

Unboxing

Integer intObject = new Integer(0);
byte byteValue = intObject; // ==> Error (the same Error with short)
int intValue = intObject;
double doubleValue = intObject;


My conclusion about unboxing is that the wrapper class gives the value wrapped by the object in the corresponding type (
Integer
==>
int
), then the compiler use the usual rules of converting primitive types (
byte
=>
short
=>
int
=>
long
=>
float
=>
double
).
I want to know if this conclusion is true or there is another concept used by auto unboxing?

Thanks for advance :)

Answer

When in doubt, check the bytecode:

Integer n = 42;

becomes:

0: bipush        42
2: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1      

So in actuality, valueOf() is used as opposed to the constructor (and the same goes for the other wrapper classes). This is beneficial since it allows for caching, and doesn't force the creation of a new object on each boxing operation.

The reverse is the following:

int n = Integer.valueOf(42);

which becomes:

0: bipush        42
2: invokestatic  #16                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: invokevirtual #22                 // Method java/lang/Integer.intValue:()I
8: istore_1      

i.e. intValue() is used (again, it's analogous for the other wrapper types as well). This is really all auto(un)boxing boils down to.

You can read about boxing and unboxing conversions in JLS §5.1.7 and JLS §5.1.8, respectively.