je Javina avtomatska pretvorba med (, ) in njihovimi (, ). Je priročna, toda ima subtilne pasti — režijo zmogljivosti, presenetljivo obnašanje in tveganje .
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 zgodi avtomatsko, ker kolekcije in generiki zahtevajo objekte (ne morete imeti List<int>), zato Java primitvne tipe transparentno pakira.
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
To je zahrbtno: == na Integer deluje za majhne vrednosti (predpomnene), toda ne uspe za velike — koda, ki se zdi pravilna pri testiranju, se zlomi v produkciji. Vedno uporabite .equals() za primerjavo vrednosti ovitkov ali najprej razpakujte na primitivne tipe.
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
Razpakiranje null ovitka vrže NPE — pogost, presenetljiv padec, posebej pri iskanju v zemljevidih, ki vrnejo 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
Ponavljajočo pakiranja/razpakiranja ustvarjajo presežne objekte, kar škoduje zmogljivosti v tesnih zankah.
Avtomatska konverzija je priročna in razširjena (kolekcije, generiki se na to zanašajo), vendar njene pasti povzročajo prave, težko diagnozirane napake.
Past == je še posebej nevarna: primerjava Integer-jev z == deluje za predpomnjene majhne vrednosti (-128 do 127), toda tiho ne uspe za večje — napaka, ki prestane teste in se zlomi v produkciji — zato je .equals() (ali razpakiranje) nujno za primerjavo ovitkov. NullPointerException iz razpakiranja null ovitkov (pogost z iskanjem v zemljevidih) je še en pogost padec.
In pakiranje v topih zankah ustvarja nepotrebne objekte, kar škoduje zmogljivosti.
Razumevanje, kdaj se pakiranja zgodi, problem primerjave reference v primerjavi z vrednostjo, tveganje null-razpakiranja in uporaba primitivnih tipov v kodi, kritični za zmogljivost, je pomembno za pisanje pravilne in učinkovite Jave — in obnašanje Integer-predpomnilnika pri == je klasično vprašanje za intervju, ki razkrije globoko razumevanje.