అనేది జావా యొక్క (, ) మరియు వాటి (, ) మధ్య స్వయంచాలక మార్పిడి. ఇది స편convenient కానిది కానీ సూక్ష్మ ఆపద్లు ఉన్నాయి — పারఫార్మెన్స్ ఓవర్హెడ్, ఆశ్చర్యకరమైన ప్రవర్తన, మరియు ప్రమాదం.
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
కలెక్షన్లు మరియు జెనెరిక్లకు ఆబ్జెక్ట్లు అవసరమవుతాయి (మీరు List<int> కలిగి ఉండలేరు), కాబట్టి జావా ప్రిమిటివ్లను పారదర్శకంగా బాక్స్ చేస్తుంది.
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
ఇది కపటమైనది: చిన్న విలువలకు (కాష్ చేయబడిన) Integer పై == పనిచేస్తుంది కానీ పెద్ద విలువలకు విఫలమవుతుంది — పరీక్షలో సరిగ్గా ఉన్న కోడ్ ఉత్పత్తిలో విచ్ఛిన్నమవుతుంది. రాపర్ విలువ సరిపోల్చడానికి ఎల్లప్పుడు .equals() ను ఉపయోగించండి, లేదా ముందుగా ప్రిమిటివ్లను అన్బాక్స్ చేయండి.
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
null రాపర్ను అన్బాక్స్ చేయడం NPE విసురుతుంది — సాధారణ, ఆశ్చర్యకరమైన క్రాష్, ముఖ్యంగా 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
పదేపదే బాక్సింగ్/అన్బాక్సింగ్ అధిక ఆబ్జెక్ట్లను సృష్టిస్తుంది, ఇక్కని లూప్లలో పారఫార్మెన్స్ను దెబ్బ కొట్టుకుంటుంది.
ఆటోబాక్సింగ్ సుবిధాजनకమైనది మరియు విస్తృతమైనది (కలెక్షన్లు, జెనెరిక్లు అన్నీ దానిపై ఆధారపడతాయి), కానీ దాని ఆపద్లు నిజమైన, కఠిన-నిర్ధారణ చేయవలసిన బగ్లను కలిగిస్తాయి.
== ఫంతతర ప్రత్యేకంగా ప్రమాదకరమైనది: Integerలను == తో సరిపోల్చడం కాష్చేయబడిన చిన్న విలువలకు (-128 నుండి 127) పనిచేస్తుంది కానీ పెద్ద విలువలకు నిశ్శబ్దంగా విఫలమవుతుంది — పరీక్షలను పాస్ చేసే కానీ ఉత్పత్తిలో విచ్ఛిన్నమయ్యే బగ్ — .equals() (లేదా అన్బాక్సింగ్) రాపర్ సరిపోల్చడానికి అవసరం. అన్బాక్సింగ్ null రాపర్ల నుండి NullPointerExceptions (మ్యాప్ లుకప్లతో సాధారణమైనది) మరొక తరచుగా క్రాష్.
మరియు హాట్ లూప్లలో బాక్సింగ్ అనవసరమైన ఆబ్జెక్ట్లను సృష్టిస్తుంది, పారఫార్మెన్స్ను గాయపరుస్తుంది.
బాక్సింగ్ ఎప్పుడు జరుగుతుందో, విలువ-మరియు-సూచిక సరిపోల్చడం సమస్య, null-అన్బాక్సింగ్ ప్రమాదం, మరియు పారఫార్మెన్స్-క్రిటికల్ కోడ్లో ప్రిమిటివ్లను ఉపయోగించడం సరిగ్గా, సమర్థవంతమైన జావాను వ్రాయడానికి ముఖ్యమైనది — మరియు Integer-కాష్ == ప్రవర్తన లోతైన అవగతను ప్రকటం చేసే క్లాసిక్ ఇంటర్వ్యూ ప్రశ్న.