दिलचस्प पोस्ट
खुद के साथ एक रजिस्टर XORing का उद्देश्य क्या है? int को dereferenced नहीं किया जा सकता PHP: संदर्भ URL कैसे प्राप्त करें? PHP में MySQL प्रतिक्रिया से मैं "रिसोर्स आईडी # 6" को कैसे "गूंज" कर सकता हूं? एलिमेंट-वार 2 सूचियों के अलावा? यूट्यूब लिंक के लिए नियमित अभिव्यक्ति हाशमैप में आंशिक खोज jquery validator के साथ एक ही नाम वाले एकाधिक टेक्स्टबॉक्स को मान्य करने से केवल पहले इनपुट मान्य है बाहरी जेएस फाइल में एस्पनेट एमवीसी यूआरएल। एक्शन। मैं कई प्रारूपों के दोहराव वाले उपायों को विस्तृत प्रारूप में कैसे फैल सकता हूं? यह जांचने का सबसे अच्छा तरीका क्या है कि कोई फ़ाइल सी में मौजूद है या नहीं? (पार मंच) मैं स्कैनर (जावा) के साथ इसे कैसे प्रबंधित कर सकता हूं? ओक्टेव / मैटलैब: एक वेक्टर में नए तत्व जोड़ना जावास्क्रिप्ट में एक ऑब्जेक्ट की पहली संपत्ति कैसे पहुंचेगी? IEnumerable <struct> को IEnumerable <object> के रूप में क्यों नहीं डाला जा सकता?

पूर्णांक लगातार पूल परिवर्तन का व्यवहार 127 पर क्यों होता है?

मैं समझ नहीं पा रहा हूं कि पूर्णांक के लिए जावा कॉन्स्टेंट पूल कैसे काम करता है।

मैं स्ट्रिंग्स के व्यवहार को समझता हूं, और इसलिए अपने आप को औचित्य करने में सक्षम हूं कि यह पूर्णांक स्थिरियों के साथ भी यही मामला है।

इसलिए, इंटीजर्स के लिए

Integer i1 = 127; Integer i2 = 127; System.out.println(i1==i2); // True 

और

 Integer i1 = new Integer(127); Integer i2 = new Integer(127); System.out.println(i1==i2); // False 

यहां तक ​​कि सब कुछ मेरे सिर में चला जाता है।

जो मैं पचाने में सक्षम नहीं हूं, वह अलग तरह से व्यवहार करता है जब मैं 127 से पूर्णांक बढ़ाता हूं। यह व्यवहार 127 के बाद बदलता है, नीचे कोड स्निपेट है

 Integer i1 = 128; Integer i2 = 128; System.out.println(i1==i2); // False. WHY????? 

क्या कोई मेरी मदद कर सकता है?

Solutions Collecting From Web of "पूर्णांक लगातार पूल परिवर्तन का व्यवहार 127 पर क्यों होता है?"

नहीं, संख्याओं के लिए निरंतर पूल स्ट्रिंग्स के समान ही काम नहीं करता है। स्ट्रिंग के लिए, केवल संकलन-समय स्थिरों को इंटर्न दिया जाता है – जबकि पूर्णांक प्रकार के आवरण प्रकार के लिए, किसी भी मुक्केबाजी अभियान हमेशा उस पूल का उपयोग करेगा, यदि वह उस मूल्य के लिए लागू हो। उदाहरण के लिए:

 int x = 10; int y = x + 1; Integer z = y; // Not a compile-time constant! Integer constant = 11; System.out.println(z == constant); // true; reference comparison 

जेएलएस जमा किए गए मूल्यों की एक छोटी सी सीमा की गारंटी देता है, लेकिन यदि वे चाहें तो एक व्यापक रेंज का उपयोग कर सकते हैं।

ध्यान दें कि यद्यपि इसकी गारंटी नहीं है, मैं हर Integer.valueOf को देखता हूं जो मुक्केबाजी कार्यों को पूरा करने के लिए Integer.valueOf का उपयोग करता है – ताकि आप भाषा की सहायता के बिना एक ही प्रभाव पा सकें।

 Integer x = Integer.valueOf(100); Integer y = Integer.valueOf(100); System.out.println(x == y); // true 

जेएलएस के अनुभाग 5.1.7 से :

यदि मान पी बॉक्सिंग सही है, गलत, एक बाइट, या एक रेंज को सीमा में \ u0000 से \ u007f, या एक int या छोटी संख्या के बीच -128 और 127 (समावेशी), तो r1 और r2 का परिणाम हो पी के किसी भी दो मुक्केबाजी रूपांतरण यह हमेशा ऐसा मामला है कि r1 == r2

आदर्श रूप से, किसी दिए गए आदिम मूल्य को मुक्केबाजी करना, हमेशा एक समान संदर्भ पैदा करेगा। व्यवहार में, यह मौजूदा कार्यान्वयन तकनीकों का उपयोग करना संभव नहीं हो सकता है। ऊपर दिए गए नियम व्यावहारिक समझौता हैं। ऊपर दिए गए अंतिम खंड के लिए आवश्यक है कि कुछ सामान्य मानों को हमेशा अलग-अलग पहचाने जाने योग्य ऑब्जेक्ट में बॉक्स किया जाना चाहिए। कार्यान्वयन इन, आलसी या बेसब्री से कैश कर सकते हैं अन्य मूल्यों के लिए, यह प्रपत्र प्रोग्रामर के भाग पर बॉक्सिंग मानों की पहचान के बारे में कोई मान्यताओं को अस्वीकार करता है। यह कुछ या सभी संदर्भों को साझा करने (लेकिन आवश्यकता नहीं) की अनुमति देगा

यह सुनिश्चित करता है कि अधिकतर सामान्य मामलों में, अनुचित प्रदर्शन जुर्माना विशेषकर छोटे उपकरणों पर लागू किए बिना व्यवहार वांछित होगा। कम मेमोरी-सीमित कार्यान्वयन, उदाहरण के लिए, सभी चार और लघु मूल्यों को कैश कर सकते हैं, साथ ही इंट और लाँग वेल्यू -32 के टू -32 के रेंज में।

जावा -128 से 127 तक पूर्णांक पूल बनाए रखता है

नीचे की तरह पूर्णांक घोषित करना

 Integer i1 = 127; 

में करने के लिए परिणाम

 Integer i1 = Integer.valueOf(127); 

तो पहले मामले के लिए वास्तव में क्या हो रहा है

 Integer i1 = 127;<---Integer.valueOf(127); Integer i2 = 127;<---Integer.valueOf(127);<---Same reference as first 

कक्षा के valueOf लिए Integer स्रोत कोड से विधि के अनुसार

 public static Integer valueOf(int i) { if(i >= -128 && i <= IntegerCache.high) return IntegerCache.cache[i + 128]; else return new Integer(i); } 

तो आपको वही सन्दर्भ मिलता है यदि मान -128 से 127 बीच होता है और आप मूल्य कॉल करते हैं तो यह सिर्फ new Integer(i) देता है new Integer(i)

और क्योंकि संदर्भ समान है आपका == ऑपरेटर इस श्रेणी के मूल्य के द्वारा वापस आने वाले पूर्णांक के लिए काम करता है।

जावा श्रेणी -128 to 127 में पूर्णांक ऑब्जेक्ट कैश करता है। इसलिए, जब आप wrapper ऑब्जेक्ट में इस श्रेणी में कोई मान निर्दिष्ट करने का प्रयास करते हैं, तो boxing संचालन Integer.valueOf विधि को आमंत्रित करेगा और बदले में यह पूल के पहले ऑब्जेक्ट के संदर्भ को निर्दिष्ट करेगा।

दूसरी तरफ, यदि आप इस रेंज से बाहर एक wrapper संदर्भ प्रकार के लिए मान असाइन करते हैं, तो Integer.valueOf उस मान के लिए एक नया Integer वस्तु बना देगा। और इसलिए, इस श्रेणी के बाहर मूल्य वाले Integer वस्तुओं के reference तुलना करना आपको false देगी

इसलिए,

 Integer i = 127; --> // Equivalent to `Integer.valueOf(127)` Integer i2 = 127; // Equivalent to `Integer.valueOf(128)` // returns `new Integer(128)` for value outside the `Range - [-128, 127]` Integer i3 = 128; Integer i4 = 128; System.out.println(i == i2); // true, reference pointing to same literal System.out.println(i3 == i4); // false, reference pointing to different objects 

लेकिन, जब आप new ऑपरेटर का उपयोग कर अपने पूर्णांक उदाहरण बनाते हैं, तो एक नया ऑब्जेक्ट हीप पर बनाया जाएगा। इसलिए,

 Integer i = new Integer(127); Integer i2 = new Integer(127); System.out.println(i == i2); // false 

जावा कैश पूर्णांक के नए संस्करणों में -128 से 127 रेंज (256 मान) में है। इधर देखो

क्या वास्तव में == के साथ Integers तुलना करता है?