ist die automatische Konvertierung von Java zwischen (, ) und ihren (, ). Es ist praktisch, hat aber subtile Fallstricke — Performance-Overhead, überraschendes -Verhalten und -Risiko.
intdoubleIntegerDouble==NullPointerExceptionInteger boxed = 42; // autoboxing: int → Integer (Integer.valueOf(42))
int unboxed = boxed; // auto-unboxing: Integer → int (boxed.intValue())
List<Integer> nums = new ArrayList<>();
nums.add(5); // autoboxes int 5 → Integer (collections need objects)
int x = nums.get(0); // auto-unboxes Integer → int
Es geschieht automatisch, da Collections und Generics Objekte benötigen (du kannst kein List<int> haben), also boxt Java Primitive transparent.
Integer a = 1000;
Integer b = 1000;
a == b; // ❌ FALSE — different Integer OBJECTS (reference comparison)
a.equals(b); // ✅ true — value comparison
// the WORSE trap — the Integer cache makes small values seem to work:
Integer c = 100, d = 100;
c == d; // TRUE — Java CACHES Integers from -128 to 127 (same object)
Integer e = 200, f = 200;
e == f; // FALSE — outside the cache range → different objects
Das ist tückisch: == auf Integer funktioniert für kleine Werte (gecacht), schlägt aber für große fehl — Code, der in Tests richtig aussieht, bricht in der Produktion. Verwende immer .equals() für Wrapper-Wertvergleiche oder entboxe zuerst zu Primitiven.
Integer value = null; // a wrapper can be null
int x = value; // 💥 NullPointerException — unboxing null calls null.intValue()
Map<String, Integer> map = new HashMap<>();
int count = map.get("missing"); // 💥 NPE — get() returns null, then unboxing fails
Das Entboxen einer null-Wrapper wirft eine NPE — ein häufiger, überraschender Crash, besonders bei Map-Lookups, die null zurückgeben.
// ❌ autoboxing in a hot loop — creates millions of Integer objects (GC pressure, slow)
Long sum = 0L; // WRONG type — wrapper
for (long i = 0; i < 1_000_000; i++) {
sum += i; // unbox, add, re-box → new Long each iteration!
}
// ✅ use primitives in hot paths
long sum = 0L; // primitive — no boxing
Wiederholtes Boxing/Unboxing erzeugt übermäßige Objekte und schadet der Performance in engen Schleifen.
Autoboxing ist praktisch und allgegenwärtig (Collections, Generics verlassen sich darauf), aber seine Fallstricke verursachen echte, schwer zu diagnostizierende Bugs.
Die ==-Falle ist besonders gefährlich: Der Vergleich von Integer mit == funktioniert für gecachte kleine Werte (-128 bis 127), schlägt aber still für größere fehl — ein Bug, der Tests besteht und in der Produktion fehlschlägt — macht .equals() (oder Unboxing) für Wrapper-Vergleiche unverzichtbar. NullPointerExceptions vom Unboxing von null-Wrappern (häufig bei Map-Lookups) sind ein weiterer häufiger Crash.
Und Boxing in Hot Loops erzeugt unnötige Objekte und schadet der Performance.
Zu verstehen, wann Boxing auftritt, das Wert-vs.-Referenz-Vergleichsproblem, das Null-Unboxing-Risiko und die Verwendung von Primitiven in Performance-kritischem Code ist wichtig für das Schreiben von korrektem, effizientem Java — und das Integer-Cache ==-Verhalten ist eine klassische Interviewfrage, die tiefes Verständnis offenbart.