është shndërrimi automatik i Java midis (, ) dhe të tyre (, ). Është i përshtatshëm, por ka rreziqe delikate — overhead performancë, sjellje shokante e , dhe rrezik .
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
Kjo ndodh automatikisht sepse koleksionet dhe generic-et kërkojnë objekte (nuk mund të kesh List<int>), kështu që Java bën boxing të primitive-ave në mënyrë transparente.
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
Kjo është insidiozë: == në Integer funksionon për vlera të vogla (të cache-uara) por dështon për ato të mëdha — kodi që duket korrekt në testim bie në prodhim. Gjithmonë përdorni .equals() për krahasimin e vlerës wrapper, ose hiqni box-in në primitive-a fillimisht.
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
Hiqja e box-it nga një wrapper null hedh një NPE — një përplasje e zakonshme, shokante, veçanërisht me kërkimet në hartë që kthejnë 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 i përsëritur krijon objekte të tepërta, duke dëmtuar performancën në cikle të ngushta.
Autoboxing është i përshtatshëm dhe i përhapur (koleksionet, generic-et mbështeten të gjithë në të), por rreziqet e tij shkaktojnë gabime të vërteta, të vështira për t'u diagnostikuar.
Rreziku i == është veçanërisht i rrezikshëm: krahasimi i Integer-ave me == funksionon për vlerat e vogla të cache-uara (-128 deri 127) por dështon në heshtje për ato më të mëdha — një gabim që kalon testet dhe thyhet në prodhim — duke e bërë .equals() (ose unboxing) thelbësor për krahasimin e wrapper-ave. NullPointerException-et nga unboxing i wrapper-ave null (të zakonshme me kërkimet në hartë) janë një tjetër rruzullim i shpeshtë.
Dhe boxing në cikle të nxehta krijon objekte të panevojshme, duke dëmtuar performancën.
Përmendja kur ndodh boxing, çështja e krahasimit të vlerës kundrejt referencës, rreziku i unboxing-ut null, dhe përdorimi i primitive-ave në kodin kritik të performancës është e rëndësishme për të shkruar Java të saktë, efikase — dhe sjellja e Integer-cache == është një pyetje klasike intervishtimi që zbulon kuptim të thellë.