este conversia automată a Java-ului între (, ) și obiectele lor (, ). Este convenabil, dar are limitări subtile — suprasarcină de performanță, comportament surprinzător al și riscul .
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
Se întâmplă automat deoarece colecțiile și genericii necesită obiecte (nu puteți avea List<int>), deci Java boxează primitivele în mod 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
Acesta este insidios: == pe Integer funcționează pentru valori mici (memorate în cache), dar eșuează pentru valori mari — codul care pare corect în testare se rupe în producție. Folosiți întotdeauna .equals() pentru compararea valorilor wrapper, sau deblocați primitivele mai întâi.
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
Deblocarea unui wrapper null aruncă o NPE — o cădere obișnuită și surprinzătoare, în special cu căutări în mapuri care returnează null.
// ❌ 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
Boxing/unboxing repetat creează obiecte în exces, afectând performanța în bucle strânse.
Autoboxing este convenabil și omniprezent (colecțiile, genericii se bazează pe el), dar limitările sale provoacă erori reale și greu de diagnosticat.
Capcanul == este deosebit de periculos: compararea Integer-ilor cu == funcționează pentru valori mici memorate în cache (-128 la 127), dar eșuează în tăcere pentru valori mai mari — o eroare care trece testele și se rupe în producție — ceea ce face .equals() (sau unboxing) esențial pentru compararea wrapper-elor. NullPointerException-urile din unboxing-ul wrapper-elor null (frecvente la căutări în mapuri) sunt o altă cădere frecventă.
Şi boxing-ul în bucle calde creează obiecte inutile, afectând performanța.
Înțelegerea când se întâmplă boxing-ul, problema comparației valoare-vs-referință, riscul null-unboxing și utilizarea primitivelor în codul critic pentru performanță este importantă pentru scrierea unui Java corect și eficient — și comportamentul == al cache-ului Integer este o întrebare clasică la interviuri care relevă o înțelegere profundă.