Search code examples
javaautoboxingunboxing

How does auto boxing/unboxing work in Java?

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?

Solution

  • 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.