Why Swapping Two Integers Fails in Java? Exploring Pass‑by‑Value, Handles, and Integer Caching

When faced with an interview question that asks to swap two Integer variables, many developers try a straightforward solution that ends up producing incorrect results.

The root cause lies in Java's memory model and how objects are accessed. In the JVM, object references stored in the stack point to either a handle in a handle pool or directly to the object's address in the heap.

Using a handle means the reference stores a stable handle address; the actual object data can move during garbage collection without changing the reference. Direct pointers store the object's address directly, offering faster access but requiring updates when the object moves.

Java passes arguments by value, meaning the method receives a copy of the reference. For primitive types this is a copy of the value; for objects it is a copy of the reference. Therefore, reassigning the parameters inside the method does not affect the original variables.

Although Integer appears to be an object, it is immutable: its internal value field is declared final, and there is no setter to change it. This immutability is similar to String.

One might attempt to bypass immutability using reflection:

However, trying to set a private final field results in an IllegalAccessException unless Field.setAccessible(true) is used. Even then, modifying the cached Integer values only affects the IntegerCache, not the original boxed values used elsewhere.

The JVM maintains an IntegerCache for values between -128 and 127. Calls to Integer.valueOf(int) return cached instances for this range, which explains why certain swaps appear to work for small numbers but not for larger ones.

Bytecode inspection (e.g., javap -c Test.class) shows the compiler automatically inserts boxing and unboxing instructions, confirming the underlying autoboxing behavior.

In summary, the swap fails because Java passes object references by value, Integer objects are immutable, and the IntegerCache mechanism returns shared instances for small values, making direct modification via reflection ineffective for the intended purpose.