ialah penukaran automatik Java antara (, ) dengan mereka (, ). Ia mudah tetapi mempunyai perangkap halus — overhed prestasi, tingkah laku yang mengejutkan, dan 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
Ia berlaku secara automatik kerana collections dan generics memerlukan objek (anda tidak boleh mempunyai List<int>), jadi Java membungkus primitif secara telus.
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
Ini sangat licik: == pada Integer berfungsi untuk nilai kecil (di-cache) tetapi gagal untuk nilai besar — kod yang kelihatan betul semasa ujian rosak dalam produksi. Sentiasa gunakan .equals() untuk perbandingan nilai wrapper, atau unbox kepada primitif terlebih dahulu.
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
Meng-unbox wrapper null membuang NPE — kemalangan biasa yang mengejutkan, terutamanya dengan carian map yang memulangkan 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 berulang mencipta objek yang berlebihan, menjejaskan prestasi dalam gelung ketat.
Autoboxing mudah dan meluas (collections, generics semuanya bergantung padanya), tetapi perangkapnya menyebabkan pepijat sebenar yang sukar didiagnosis.
Perangkap == amat berbahaya: membandingkan Integer dengan == berfungsi untuk nilai kecil yang di-cache (-128 hingga 127) tetapi gagal secara senyap untuk yang lebih besar — pepijat yang lulus ujian dan rosak dalam produksi — menjadikan .equals() (atau unboxing) penting untuk perbandingan wrapper. NullPointerException daripada meng-unbox wrapper null (biasa dengan carian map) ialah satu lagi kemalangan yang kerap berlaku.
Dan boxing dalam gelung panas mencipta objek yang tidak perlu, menjejaskan prestasi.
Memahami bila boxing berlaku, isu perbandingan nilai-lawan-rujukan, risiko null-unboxing, dan menggunakan primitif dalam kod kritikal-prestasi adalah penting untuk menulis Java yang betul dan cekap — dan tingkah laku == Integer-cache ialah soalan temu duga klasik yang mendedahkan pemahaman mendalam.
Pustaka soalan temu duga IT dengan jawapan terperinci — daripada Junior hingga Senior.
Derma