Autoboxing and Unboxing in Java

Updated March 14, 2023

Introduction to Autoboxing and Unboxing in Java

Autoboxing is Java compiler’s automatic conversion between the primitive types and their corresponding wrapper class objects, i.e., conversion from int to Integer, double to Double, etc. Unboxing is the automatic conversion from wrapper class objects to their equivalent primitives, i.e., Integer to int. The feature was introduced in version 1.5 of Java.

How do Autoboxing and Unboxing work in Java?

The compiler uses valueOf() method to convert primitives to corresponding wrapper objects (i.e. autoboxing) internally, and in the vice versa case, it uses intValue(), doubleValue(), etc., like paradigms for unboxing.

The primitive type and wrapper class mapping in java are as follows:

Examples

Let’s take an ArrayList of Integers and make use of the unboxing concept.

import java.util.ArrayList;
public class MyClass {
public static void main(String args[]) {
ArrayList<Integer> intlist = new ArrayList<Integer>();
//wrapper Integer objects being added here
intlist.add(1);
interest.add(2);
//auto-unboxing is happening here
int x = intlist.get(0);
System.out.println(x);
}
}

Hence, in the above example, while adding value to x, we see that x appears to be primitive. As a result, unboxing happens here automatically while the assignment is done.

public class MyClass {
public static void main(String args[]) {
Integer sum =0;
for(int i=0;i<10;i++)
{
sum = sum + i;
}
System.out.println(sum);
}
}

• Above, we have shown a second example in this context, where a typical scenario has been presented. If you are acquainted with object creation in Java, you can see that “Integer sum =0” declares an object, and when we do computation inside for the loop, then we can see that the primitive value “i” is being added to the wrapper “sum.”
• Hence, one can find that first, conversion from wrapper to primitive will occur, as the “+” operator works on primitives only; hence, object unboxing will happen first. Then, the computation will occur, and after that, object autoboxing will occur again. Then, the value will be assigned to the variable “sum.”
• This presents unnecessary overhead on the JVM as many intermediate Integer objects will be created and then destroyed (to be later garbage collected), thereby causing a slowdown. As a result, such logics shall be handled with caution.
• Let’s see how the conditions differ from general perceptions. To understand autoboxing and unboxing, we will use some coding.

Consider the snippet placed below; what will be the output of this?

public class Main
{
public static void main(String[] args) {
Integer m = 34123;
Integer x = 34123;
System.out.println(x==m);
}
}

• If you are saying “true,”  then you are “false,” because the output is also “false.” Since we can compare the integer range from -128 to 127, values going outside of this range need to be unboxed.
• As a result, we must compare intValue() of the above integers. For now, the compiler does this using the valueOf() property.
• Likely, if this falls in the range cited above, then the above code as it is will give “true”— since it will first refer to the integer literal pool for comparison.

public class Main
{
public static void main(String[] args) {
Integer m = 100;
Integer x = 100;
System.out.println(x==m);
}
}

This will evaluate to “true” value, as 100 is present in the literal pool.

Autoboxing and Unboxing in Java with Method Overloading

• Before we tag autoboxing and unboxing with method overloading, we assume that the reader understands the concept of method overloading. We will only give few insights, and for more information, please refer to Oracle’s documentation on the same.
• Method overloading is the process of presenting multiple variants of any computation method by using the same method name with a different number of input arguments, different data types of variables with the same names, and so on.
• Let’s take an example to understand it better. The output image is displayed below.

public class Main
{
public static void main(String[] args) {
Overload obj =  new Overload();
int i =5;
obj.printval(5);
Integer m = i;
obj.printval(m);
}
}
class Overload
{
public void printval(int i)
{
System.out.println("printing the unboxed value "+ i);
}
public void printval(Integer i)
{
System.out.println("printing the autoboxed value "+ i);
}
}

Output:

• As a result, the above behavior indicates unequivocally that the autoboxing technique is useful for overloading concepts and should be used with caution when coding.

Advantages of Autoboxing and Unboxing in Java

• The compiler automatically undertakes the appropriate conversion.
• The developer writes less code, thereby creating cleaner code.
• No need for manual type-casting expressions.

 Conclusion

We saw the use case of autoboxing and unboxing and how implicit this concept is, along with its pros and cons. It must be used with caution when coding; otherwise, it can add unnecessary computational conversion overhead. Consequently, conversions must be done in primitives to avoid excessive garbage collection overhead and temporary object creation. We also saw the use case of autoboxing with the overload concept in Java. You can check a few more constraints along with this.

Recommended Articles

Related to Java, you can go through our following articles to expand your understanding:

1. What is JDBC?
2. What is Generics in Java?
3. Groovy vs Java
4. What is Java Inheritance?