ni ubadilishaji wa kiotomatiki wa Java kati ya (, ) na zao (, ). Ni rahisi lakini ina matatizo dakika — overhead ya utendaji, tabia ya kushangaza ya , na hatari ya .
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
Hutokea kiotomatiki kwa sababu collections na generics zinahitaji objects (huwezi kuwa na List<int>), kwa hivyo Java huweka primitives kwenye box kwa uwazi.
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
Hii ni hatari: == kwenye Integer hufanya kazi kwa thamani ndogo (cached) lakini hushindwa kwa kubwa — msimbo unaoonekana sahihi katika testing huvunjika katika uzalishaji. Daima tumia .equals() kwa ulinganishaji wa thamani ya wrapper, au unbox kwenda primitives kwanza.
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
Ku-unbox wrapper ya null hutupa NPE — crash ya kawaida, ya kushangaza, hasa na map lookups zinazorudisha 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
Kuweka/kuondoa kwenye box mara kwa mara huunda objects nyingi kupita kiasi, kuumiza utendaji katika loops zenye msongamano.
Autoboxing ni rahisi na imeenea (collections, generics zote zinaitegemea), lakini matatizo yake husababisha bugs halisi, ngumu kutambua.
Tatizo la == ni hatari hasa: kulinganisha Integers kwa == hufanya kazi kwa thamani ndogo zilizo-cache (-128 hadi 127) lakini hushindwa kimya kwa kubwa — bug inayopita tests na kuvunjika katika uzalishaji — kufanya .equals() (au unboxing) kuwa muhimu kwa ulinganishaji wa wrapper. NullPointerExceptions kutoka kwa ku-unbox wrappers za null (za kawaida na map lookups) ni crash nyingine ya mara kwa mara.
Na boxing katika hot loops huunda objects zisizohitajika, kuumiza utendaji.
Kuelewa lini boxing hutokea, suala la ulinganishaji wa value-vs-reference, hatari ya null-unboxing, na kutumia primitives katika msimbo nyeti kwa utendaji ni muhimu kwa kuandika Java sahihi, yenye ufanisi — na tabia ya == ya Integer-cache ni swali la kawaida la mahojiano linalofunua uelewa wa kina.