तुलना पूर्णांक वस्तुओं

Question

मैं निम्नलिखित कोड है:

public class Test { 

    public static void main(String[] args) { 

     Integer alpha = new Integer(1); 
     Integer foo = new Integer(1); 

     if(alpha == foo) { 
      System.out.println("1. true"); 
     } 

     if(alpha.equals(foo)) { 
      System.out.println("2. true"); 
     } 

    } 

} 

उत्पादन इस प्रकार है के रूप में:

2. true 

हालांकि एक int को Integer object का प्रकार बदलने उदाहरण के लिए एक अलग उत्पादन का उत्पादन होगा,:

public class Test { 

    public static void main(String[] args) { 

     Integer alpha = new Integer(1); 
     int foo = 1; 

     if(alpha == foo) { 
      System.out.println("1. true"); 
     } 

     if(alpha.equals(foo)) { 
      System.out.println("2. true"); 
     } 

    } 

} 

नया आउटपुट:

1. true 
2. true 

यह कैसे हो सकता है? पहला उदाहरण कोड आउटपुट 1. true क्यों नहीं है?

Answer 1

संदर्भ प्रकारों के लिए, == जांच करता है कि संदर्भ बराबर हैं या नहीं, यानी वे एक ही वस्तु को इंगित करते हैं या नहीं।

आदिम प्रकारों के लिए, == जांचता है कि मान बराबर हैं या नहीं।

java.lang.Integer एक संदर्भ प्रकार है। int एक आदिम प्रकार है।

संपादित करें: यदि एक ऑपरेंड आदिम प्रकार का है, और एक अन्य संदर्भ प्रकार जो उपयुक्त आदिम प्रकार के लिए अनबॉक्स करता है, == मूल्यों की तुलना करेगा, न कि संदर्भों से।

Answer 2

== ऑब्जेक्ट्स के लिए जांच करता है कि संदर्भ समान हैं, इसलिए यह Integers के लिए झूठा रिटर्न देता है। हालांकि मूल प्रकारों के लिए (इनट्स, फ्लोट्स, ...) यह समानता की जांच करता है, यही कारण है कि आप सच हो जाते हैं।

मुझे यह उल्लेख करना चाहिए कि पहले मामले में, जहां आप एक इंटीजर और एक int की तुलना करते हैं, int int इंटीजर ऑब्जेक्ट (ऑटोबॉक्सिंग) में परिवर्तित हो जाती है, और फिर संदर्भ तुलना होती है। चूंकि वे अलग हैं, यह झूठी वापसी करता है।

Answer 3

इंटीजर ऑब्जेक्ट्स ऑब्जेक्ट्स हैं। यह तार्किक लगता है, लेकिन सवाल का जवाब है। ऑब्जेक्ट्स को जावा में new कीवर्ड का उपयोग करके बनाया जाता है, और फिर स्मृति में संग्रहीत किया जाता है। तुलना करते समय, आप ऑब्जेक्ट्स के मेमोरी स्थानों की तुलना करते हैं, न कि ऑब्जेक्ट्स के मान/गुण।

.equals() पद्धति का उपयोग करना, आप वास्तव में मूल्यों वस्तुओं की/गुण, नहीं स्मृति में उनके स्थान की तुलना:

new Integer(1) == new Integer(1) रिटर्न false, जबकि new Integer(1).equals(new Integer(1)) रिटर्न true।

---

int एस जावा का एक प्राचीन प्रकार है। जब आप एक int बनाते हैं, तो संदर्भित सभी मूल्य मान है। जब आप जावा में किसी भी आदिम प्रकार की तुलना करते हैं, तो तुलना की गई सभी चीजें मान हैं, स्मृति स्थान नहीं। यही कारण है कि 5 == 5 हमेशा सच होता है।

जब आप Integer ऑब्जेक्ट को एक आदिम प्रकार से तुलना करते हैं, तो ऑब्जेक्ट को यथासंभव प्राचीन प्रकार में डाला जाता है। Integer और int के साथ यह संभव है, इसलिए उनकी तुलना की जाती है। यही कारण है कि Integer(1).equals(1) सच देता है।

Answer 4

पूर्णांक == यहाँ पूर्णांक ऑटो मुक्केबाजी लागू किया तो सच (ताकि पूर्णांक तुलना से पहले int करने के लिए परिवर्तित) .. लेकिन पूर्णांक == पूर्णांक यहाँ तुलना आपत्ति .. इसलिए संदर्भ के रूप में अलग अलग इसलिए झूठे हैं

Answer 5

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

दूसरा उदाहरण: एक रैपर प्रकार (इंटीजर, लांग, इत्यादि) और एक संख्यात्मक प्रकार (int, long, आदि) के बीच == का उपयोग करते समय रैपर प्रकार अनबॉक्स किया जाता है और समानता जांच के बीच की जाती है दो आदिम संख्यात्मक प्रकार (Ie int और int) के बीच। अनबॉक्सिंग बाइनरी न्यूमेरिक पदोन्नति का हिस्सा है, यहां और पढ़ें: http://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.6.2

Answer 6

नई वस्तु बनाने के लिए आप new Integer(1) का उपयोग करेंगे, यह हर बार एक बिल्कुल अलग वस्तु बनाता है, भले ही उसके पास एक ही मूल्य हो। '==' जांचता है कि ऑब्जेक्ट समान हैं, डेटा मान नहीं। आपके मामले में, आप निम्न मान को चेक कर सकते थे:

if(alpha.intValue() == foo.intValue()) { 
// 
}