Autoboxing and Unboxing in Java

Before Java 5, putting a number in a list meant writing list.add(Integer.valueOf(91)), and reading it back meant list.get(0).intValue(). Now you just write list.add(91) and int m = list.get(0). Autoboxing is the compiler converting a primitive to its wrapper automatically; unboxing is the reverse. It's convenient, but the conversions are still there in the bytecode, with a cost and a trap.

Boxing and Unboxing in Action

import java.util.ArrayList;
import java.util.List;
 
public class Boxing {
    public static void main(String[] args) {
        List<Integer> marks = new ArrayList<>();
        marks.add(91);
        int first = marks.get(0);
        Integer bonus = 5;
        int total = first + bonus;
        System.out.println(total);
    }
}

96

How it works

1. marks.add(91): the list needs an Integer, so 91 is boxed.
2. int first = marks.get(0): the Integer is unboxed to an int.
3. Integer bonus = 5: boxing again.
4. first + bonus: arithmetic needs primitives, so bonus is unboxed.

What the Compiler Really Writes

javap -c shows the hidden method calls:

        11: invokestatic  #10                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        30: invokevirtual #26                 // Method java/lang/Integer.intValue:()I
        35: invokestatic  #10                 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
        41: invokevirtual #26                 // Method java/lang/Integer.intValue:()I

Boxing is Integer.valueOf(x); unboxing is x.intValue(). That's all autoboxing is: the compiler writing these calls for you.

Where Conversions Happen

The null Traps

Unboxing a null wrapper calls a method on null. The most common case is reading a missing key from a map:

import java.util.HashMap;
import java.util.Map;
 
public class Npe {
    public static void main(String[] args) {
        Map<String, Integer> marks = new HashMap<>();
        marks.put("Navika", 91);
        int m = marks.get("Advitha");
    }
}

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "java.lang.Integer.intValue()" because the return value of "java.util.Map.get(Object)" is null
    at Npe.main(Npe.java:8)

marks.get("Advitha") returns null, and assigning it to an int calls intValue() on it. The helpful message names the exact call. Fixes: marks.getOrDefault("Advitha", 0), or keep the result as an Integer and check it.

A sneakier version hides in the conditional operator: Integer applied = member ? 10 : discount; throws when discount is null, because the mix of int and Integer makes the whole expression an int, which unboxes discount.

Common Mistakes

Unboxing a value that might be null. Check first, or use getOrDefault.

Using wrapper types for loop counters and sums. Use int and long.

Comparing two Integer objects with ==. Boxing doesn't make == compare values (see "Integer Cache in Java").

Interview Corner

Practice

1. Easy: Store five scores in a List<Integer>, then add them up into an int total using a for-each loop. Which lines box and which unbox?
2. Harder: Fix Npe.java two ways: with getOrDefault, and by keeping the result as an Integer and printing "not found" when it's null.

Key Takeaways