जावा में दो इंटेगर की ठीक से तुलना कैसे करें?

Question

मुझे पता है कि यदि आप एक निरंतर के साथ एक बॉक्सिंग आदिम इंटेगर की तुलना करते हैं:

Integer a = 4;
if (a < 5)

a स्वचालित रूप से अनबॉक्स हो जाएगा और तुलना काम करेगी।

हालाँकि, क्या होता है जब आप दो बॉक्सिंग की तुलना कर रहे हैं Integersऔर समानता या उससे कम / अधिक की तुलना करना चाहते हैं?

Integer a = 4;
Integer b = 5;

if (a == b)

उपरोक्त कोड का परिणाम यह देखने के लिए होगा कि क्या वे एक ही वस्तु हैं, या क्या यह उस स्थिति में ऑटो-अनबॉक्स नहीं होगा?

व्हाट अबाउट:

Integer a = 4;
Integer b = 5;

if (a < b)

?

Comments

खैर, जब आपने कोशिश की तो क्या हुआ? आपने क्या अवलोकन किया?

— बार्ट किर्स ऑक्ट

@ बर्ट कियर्स: एक स्पष्ट प्रयोग केवल नापसंद हो सकता है, यह साबित नहीं करता है कि अनबॉक्सिंग होता है। यदि पैदावार के ==बजाय equalsसही परिणाम का उपयोग किया जाता है , तो ऐसा इसलिए हो सकता है क्योंकि बॉक्सिंग नंबरों को नजरअंदाज किया जा रहा है या अन्यथा पुन: उपयोग किया जा रहा है (संकलक अनुकूलन के रूप में, संभवतः)। इस प्रश्न को पूछने का कारण यह पता लगाना है कि आंतरिक रूप से क्या हो रहा है, न कि ऐसा प्रतीत होता है कि क्या हो रहा है। (कम से कम, इसीलिए मैं यहाँ हूँ।)

— जिम पिवार्स्की

आपके खाते का क्या हुआ?

Answer 1

नहीं, == इंटेगर के बीच, लॉन्ग आदि संदर्भ समानता के लिए जाँच करेंगे - यानी

Integer x = ...;
Integer y = ...;

System.out.println(x == y);

इस जाँच करें कि क्या होगा xऔर yका उल्लेख एक ही वस्तु के बजाय बराबर वस्तुओं।

इसलिए

Integer x = new Integer(10);
Integer y = new Integer(10);

System.out.println(x == y);

प्रिंट करने की गारंटी है false। "छोटे" आटोबॉक्स्ड वैल्यूज़ की इंट्री करने से मुश्किल परिणाम हो सकते हैं:

Integer x = 10;
Integer y = 10;

System.out.println(x == y);

यह trueबॉक्सिंग के नियमों ( JLS खंड 5.1.7 ) के कारण मुद्रित होगा । यह अभी भी संदर्भ समानता है इस्तेमाल किया जा रहा है, लेकिन सही मायने में संदर्भ हैं बराबर।

यदि मूल्य p बॉक्स किया जा रहा है, तो -128 और 127 समावेशी (.103.10.1), या बूलियन शाब्दिक सही या गलत (§3.10.3), या 'u0000' और 'के बीच एक अक्षर शाब्दिक' के बीच अंतर का एक पूर्णांक शाब्दिक है। '\ u007f' समावेशी (.43.10.4), तो पी के किसी भी दो मुक्केबाजी रूपांतरणों के ए और बी परिणाम दें। यह हमेशा मामला है कि एक == बी।

व्यक्तिगत रूप से मैं उपयोग करेगा:

if (x.intValue() == y.intValue())

या

if (x.equals(y))

जैसा कि आप कहते हैं, एक आवरण प्रकार ( Integer, Longआदि) और एक संख्यात्मक प्रकार ( int, longआदि) के बीच किसी भी तुलना के लिए , आवरण प्रकार का मान अनबॉक्स किया जाता है और परीक्षण में शामिल आदिम मूल्यों पर लागू किया जाता है।

यह बाइनरी न्यूमेरिक प्रमोशन ( JLS खंड 5.6.2 ) के हिस्से के रूप में होता है । यह देखने के लिए कि क्या लागू होता है, प्रत्येक व्यक्तिगत ऑपरेटर के दस्तावेज देखें। उदाहरण के लिए, ==और !=( JLS 15.21.1 ) डॉक्स से :

यदि एक समानता ऑपरेटर के ऑपरेंड संख्यात्मक प्रकार के दोनों होते हैं, या एक संख्यात्मक प्रकार का होता है और दूसरा संख्यात्मक प्रकार के लिए परिवर्तनीय ()5.1.8) होता है, तो ऑपरेंड (binary5.6.2) पर द्विआधारी संख्यात्मक पदोन्नति होती है।

और के लिए <, <=, >और >=( JLS 15.20.1 )

एक संख्यात्मक तुलना ऑपरेटर के प्रत्येक ऑपरेंड का प्रकार एक प्रकार होना चाहिए जो कि एक आदिम संख्यात्मक प्रकार के लिए परिवर्तनीय (.15.1.8) होता है, या एक संकलन-समय त्रुटि उत्पन्न होती है। बाइनरी न्यूमेरिक प्रमोशन ऑपरेंड्स पर किया जाता है (promotion5.6.2)। यदि ऑपरेंड का प्रचारित प्रकार इंट या लंबा है, तो हस्ताक्षरित पूर्णांक तुलना की जाती है; यदि यह पदोन्नत प्रकार फ्लोट या डबल है, तो फ्लोटिंग-पॉइंट तुलना की जाती है।

ध्यान दें कि इसमें से कोई भी उस स्थिति का हिस्सा नहीं माना जाता है जहां न तो टाइप एक संख्यात्मक प्रकार है।

Comments

क्या कोई कारण है कि कोई x.compareTo(y) < 0इसके बजाय लिखना चाहेगा x < y?

— मैक्स नानसी

@MaxNanasy: ऐसा नहीं है कि मैं तुरंत सोच सकता हूं।

— जॉन स्कीट

जावा 1.6.27+ के रूप में इंटेगर वर्ग में बराबरी पर एक अधिभार है, इसलिए इसे कॉलिंग .intValue () के रूप में कुशल होना चाहिए। यह मूल्यों को आदिम इंट के रूप में तुलना करता है।

— otterslide

जैसा कि @otterslide ने कहा, जावा 8 में अब यह आवश्यक नहीं है। Integer के साथ Integer की तुलना डिफ़ॉल्ट रूप से मूल्य से होती है।

— एक्सल प्रीतो

@ एक्सल: एक अधिभार के अलावा के == ऑपरेटर के व्यवहार को नहीं बदलेगा, यह होगा? मैं अभी परीक्षण करने की स्थिति में नहीं हूं, लेकिन अगर मैं बदल गया होता तो मुझे बहुत आश्चर्य होता।

— जॉन स्कीट

Answer 2

==अभी भी वस्तु समानता का परीक्षण करेंगे। हालांकि, मूर्ख बनाना आसान है:

Integer a = 10;
Integer b = 10;

System.out.println(a == b); //prints true

Integer c = new Integer(10);
Integer d = new Integer(10);

System.out.println(c == d); //prints false

असमानताओं के साथ आपके उदाहरण काम करेंगे क्योंकि वे वस्तुओं पर परिभाषित नहीं हैं। हालांकि, ==तुलना के साथ , वस्तु समानता अभी भी जाँच की जाएगी। इस स्थिति में, जब आप ऑब्जेक्ट्स को बॉक्सिंग आदिम से इनिशियलाइज़ करते हैं, तो उसी ऑब्जेक्ट का उपयोग किया जाता है (a और b दोनों के लिए)। यह एक ठीक अनुकूलन है क्योंकि आदिम बॉक्स कक्षाएं अपरिवर्तनीय हैं।

Comments

मुझे लगा कि यह वस्तु समानता का परीक्षण किया जा रहा है। मेरे कुछ अजीब परिणाम थे। क्या मुझे (।) के साथ इसे प्रतिस्थापित करना चाहिए? इसके अलावा, क्या आपको लगता है कि मुझे असमानताओं को छोड़ देना चाहिए जैसे वे हैं या यह एक और तरीका है?

ऑटोबॉक्सिंग के साथ कुछ गैर-स्पष्ट किनारे के मामले हैं। मेरे पास मेरी आईडीई (ग्रहण) है जो लाल रंग के किसी भी बॉक्स को रंगने के लिए सेट है, इसने मुझे कुछ मौकों पर बग से बचाया है। यदि आप दो इंटिजर्स की तुलना कर रहे हैं, तो। असमान का उपयोग करें, यदि आप अपनी असमानताओं को स्पष्ट करना चाहते हैं, तो स्पष्ट रूप से कलाकारों को लिखें: यदि (((इंट) c <<(int) d) ...); आप यह भी कर सकते हैं: c.compareTo (d) <0 // === c <d

— एडम लुईस

और यदि आप संख्या शाब्दिकों को बदलते हैं 200, तो दोनों परीक्षण मुद्रित होंगे false।

— डैनियल इयरविकर

... अधिकांश JVM कार्यान्वयन पर, जो है। भाषा कल्पना के अनुसार परिणाम कार्यान्वयन के बीच भिन्न हो सकते हैं।

— डैनियल इयरविकर

मुझे लगता है कि इस "संदर्भ समानता" को कॉल करना स्पष्ट है - इस तरह से यह स्पष्ट है कि आपका क्या मतलब है। मैं सामान्य रूप से "ऑब्जेक्ट इक्वैलिटी" को "मतलब equalsहोने का परिणाम" कहूंगा ।

— जॉन स्कीट

Answer 3

Java 1.7 के बाद से आप Objects.equals का उपयोग कर सकते हैं :

java.util.Objects.equals(oneInteger, anotherInteger);

यदि तर्क एक-दूसरे के बराबर हैं और अन्यथा झूठे हैं तो सही है। नतीजतन, यदि दोनों तर्क शून्य हैं, तो सच्चा वापस आ जाता है और यदि वास्तव में एक तर्क शून्य है, तो झूठे को वापस कर दिया जाता है। अन्यथा, पहले तर्क के बराबर विधि का उपयोग करके समानता निर्धारित की जाती है।

Comments

यह नल को संभालता है इसलिए इसे सरल बनाता है। धन्यवाद!

— डैरेन पार्कर

Answer 4

== संदर्भ समानता के लिए जाँच, हालांकि कोड लिखते समय:

Integer a = 1;
Integer b = 1;

जावा के लिए एक ही अपरिवर्तनीय aऔर फिर से उपयोग करने के लिए पर्याप्त स्मार्ट है b, इसलिए यह सच है a == b:। जिज्ञासु, मैंने यह दिखाने के लिए एक छोटा सा उदाहरण लिखा जहां जावा इस तरह से अनुकूलन करना बंद कर देता है:

public class BoxingLol {
    public static void main(String[] args) {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            Integer a = i;
            Integer b = i;
            if (a != b) {
                System.out.println("Done: " + i);
                System.exit(0);
            }
        }
        System.out.println("Done, all values equal");
    }
}

जब मैं इसे (मेरी मशीन पर) संकलित और चलाता हूं, तो मुझे यह मिलता है:

Done: 128

Comments

tl; हैंड -1 को हैंडवॉशिंग के लिए; stackoverflow.com/questions/15052216/… stackoverflow.com/questions/20897020/… stackoverflow.com/questions/3131136/integers-caching-in-java आदि विस्तार से आपके द्वारा बताई गई बात को समझाते हैं; परिणामों के उच्च स्थानीयता के जोखिम के साथ छद्म परीक्षण बनाने की तुलना में डॉक्स (या काम के स्रोत) को पढ़ना बेहतर है - न केवल आप पूरी तरह से कैश के निचले हिस्से (यानी डिफ़ॉल्ट रूप से -128) के बारे में भूल गए हैं, न केवल आपके पास एक-एक (अधिकतम 127, 128 नहीं) है,

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

मैं यहां आपकी राय और धारणा का सम्मान करता हूं। मुझे लगता है कि हमारे पास सीएस के लिए मौलिक रूप से अलग दृष्टिकोण हैं।

— कोरी केंडल

यह राय और धारणा के बारे में नहीं है - यह उन तथ्यों के बारे में है , जिन्हें आपने ईमानदारी से याद किया है। किसी भी कठिन बैकिंग डेटा (डॉक्स, सोर्स इत्यादि) के बिना और बिना ओपी के सवालों के जवाब दिए, एक छद्म-परीक्षण करना, न तो अच्छा प्रश्नोत्तर कहलाता है और न ही सीएस। जैसा कि "विभिन्न दृष्टिकोण" - सीएस परिभाषा के अनुसार, एक विज्ञान है ; आपने जो किया वह विज्ञान नहीं है ; यह एक भ्रामक सामान्य ज्ञान है (या यह एक पेचीदा टिप्पणी होगी , अगर इसे ठीक से कहा जाए) - यदि आप इसे विज्ञान की इच्छा रखते हैं , तो अपने उत्तर में मूलभूत दोषों को सुधारें या उन्हें समझदारी से समझें , जैसा कि 'काम करता है।

फिर भी, मैं खामियों को दूर करने की कोशिश करूँगा। मैं निचली सीमा के बारे में नहीं भूलता था, मुझे नहीं लगा कि यह दिलचस्प था और इसे शामिल नहीं करना चुना। मुझे विश्वास नहीं है कि मेरे पास एक त्रुटि है, मैंने उस तरह से कहा कि जावा (जिसे मैंने अपनी मशीन पर स्पष्ट किया, मेरी स्थिति में) यह अनुकूलन करना बंद कर दिया , जो कि 128 पर है। यदि मैंने अधिकतम मूल्य कहा था इसके लिए, आप उत्तर सही होने के कारण 127 हो गए होंगे।

— कोरी केंडल

Answer 5

tl; dr मेरी राय +मूल्य समानता की जाँच करते समय किसी एक ऑपरेंड पर unboxing को ट्रिगर करने के लिए एक यूरीरी का उपयोग करना है, और बस मैथ्स ऑपरेटरों का अन्यथा उपयोग करें। औचित्य इस प्रकार है:

यह पहले से ही उल्लेख किया गया है कि पहचान की ==तुलना के लिए Integerतुलना है, जो आमतौर पर एक प्रोग्रामर नहीं चाहता है, और इसका उद्देश्य मूल्य तुलना करना है; फिर भी, मैंने कोड कॉम्पैक्टनेस, शुद्धता और गति दोनों की तुलना में उस कुशलता से तुलना करने के तरीके के बारे में थोड़ा सा विज्ञान किया है ।

मैंने तरीकों का सामान्य गुच्छा इस्तेमाल किया:

public boolean method1() {
    Integer i1 = 7, i2 = 5;
    return i1.equals( i2 );
}

public boolean method2() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2.intValue();
}

public boolean method3() {
    Integer i1 = 7, i2 = 5;
    return i1.intValue() == i2;
}

public boolean method4() {
    Integer i1 = 7, i2 = 5;
    return i1 == +i2;
}

public boolean method5() { // obviously not what we want..
    Integer i1 = 7, i2 = 5;
    return i1 == i2;
}

और संकलन और विघटन के बाद यह कोड मिला:

public boolean method1() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    return var1.equals( var2 );
}

public boolean method2() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method3() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method4() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2.intValue() == var1.intValue() ) {
        return true;
    } else {
        return false;
    }
}

public boolean method5() {
    Integer var1 = Integer.valueOf( 7 );
    Integer var2 = Integer.valueOf( 5 );

    if ( var2 == var1 ) {
        return true;
    } else {
        return false;
    }
}

जैसा कि आप आसानी से देख सकते हैं, विधि 1 कॉल Integer.equals()(स्पष्ट रूप से), विधियाँ 2-4 परिणाम एक ही कोड में होते हैं , मानों को बिना मतलब के अलिखित करते हैं .intValue()और फिर उनकी तुलना सीधे करते हैं, और विधि 5 सिर्फ पहचान की तुलना को ट्रिगर करता है, गलत तरीके से मूल्यों की तुलना करें।

चूंकि (जैसा कि पहले से ही जेएस द्वारा उल्लेख किया गया है) equals()एक ओवरहेड (यह instanceofएक अनियंत्रित कलाकारों को करना पड़ता है ) को लागू करता है, 2-4 तरीके समान गति के साथ काम करेंगे, तंग छोरों में उपयोग किए जाने पर विधि 1 से बेहतर रूप से बेहतर, क्योंकि हॉटस्पॉट नहीं है जातियों के अनुकूलन की संभावना है instanceof।

यह अन्य तुलना ऑपरेटरों (जैसे </ >) के साथ काफी समान है - वे उपयोग compareTo()नहीं करते हुए अनबॉक्सिंग को ट्रिगर करेंगे - लेकिन इस बार, एचएस द्वारा ऑपरेशन अत्यधिक अनुकूलन योग्य है, क्योंकि intValue()बस एक गेटर विधि है (प्रधान उम्मीदवार को अनुकूलित किया जा रहा है)।

मेरी राय में, शायद ही कभी इस्तेमाल किया गया संस्करण 4 सबसे संक्षिप्त तरीका है - हर अनुभवी सी / जावा डेवलपर जानता है कि यूनियरी प्लस ज्यादातर मामलों में कास्ट के बराबर है int/ .intValue()- जबकि यह कुछ के लिए थोड़ा डब्ल्यूटीएफ पल हो सकता है (ज्यादातर वे जो करते थे 'अपने जीवनकाल में यूरी प्लस का उपयोग न करें), यह यकीनन सबसे स्पष्ट रूप से और सबसे अधिक स्पष्ट रूप से इरादे को दिखाता है - यह दर्शाता है कि हम एक intऑपरेंड का एक मूल्य चाहते हैं , दूसरे मूल्य को भी अनबॉक्स करने के लिए मजबूर करते हैं। यह भी i1 == i2आदिम intमूल्यों के लिए उपयोग की जाने वाली नियमित तुलना के समान ही है ।

मेरा वोट के लिए चला जाता है i1 == +i2और i1 > i2के लिए शैली Integer, वस्तुओं दोनों प्रदर्शन और एकरूपता बनाए रखने के लिए। यह भी प्रकार की घोषणा के अलावा कुछ भी बदले बिना आदिम को पोर्टेबल पोर्टेबल बनाता है। नाम के तरीकों का उपयोग करना मेरे लिए अर्थ-संबंधी शोर का परिचय देने जैसा लगता है, जो कि बहुत ही आलोचनात्मक bigInt.add(10).multiply(-3)शैली के समान है ।

Comments

क्या आप बता सकते हैं कि विधि 4 में + का क्या अर्थ है? मैंने इसे गूगल करने की कोशिश की लेकिन मुझे केवल उस प्रतीक के सामान्य उपयोग (इसके अलावा, संयोजन) मिले।

— एलेक्स ली

@AlexLi का मतलब वही है जो मैंने लिखा था - unary +(

Answer 6

कॉलिंग

if (a == b)

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

समानता के लिए दो इंटेगर वर्गों की तुलना करने का सबसे उचित तरीका, यह मानते हुए कि उन्हें 'ए' और 'बी' नाम दिया गया है:

if(a != null && a.equals(b)) {
  System.out.println("They are equal");
}

आप इस तरह से भी उपयोग कर सकते हैं जो थोड़ा तेज है।

   if(a != null && b != null && (a.intValue() == b.intValue())) {
      System.out.println("They are equal");
    } 

मेरी मशीन पर 99 बिलियन ऑपरेशंस में 47 सेकंड्स लगे, पहली विधि का इस्तेमाल किया गया, और 46 सेकंड्स के दूसरे तरीके का इस्तेमाल किया गया। किसी भी अंतर को देखने के लिए आपको अरबों मूल्यों की तुलना करने की आवश्यकता होगी।

ध्यान दें कि 'a' एक ऑब्जेक्ट होने के बाद से अशक्त हो सकता है। इस तरह से तुलना करने से अशक्त सूचक अपवाद नहीं होगा।

तुलना करने के लिए अधिक से अधिक और कम का उपयोग करें

if (a != null && b!=null) {
    int compareValue = a.compareTo(b);
    if (compareValue > 0) {
        System.out.println("a is greater than b");
    } else if (compareValue < 0) {
        System.out.println("b is greater than a");
    } else {
            System.out.println("a and b are equal");
    }
} else {
    System.out.println("a or b is null, cannot compare");
}

Comments

if (a==b)केवल छोटे मूल्यों के लिए काम करता है और अधिकांश समय काम नहीं करेगा।

— टोनी

यह 127 तक काम करता है जैसा कि जावा का डिफ़ॉल्ट इंटेगर कैश है, जो यह सुनिश्चित करता है कि 127 तक के सभी नंबरों का समान संदर्भ मूल्य हो। यदि आप चाहें तो कैश को 127 से ऊपर जाने के लिए सेट कर सकते हैं, लेकिन सुरक्षित होने के लिए बस == का उपयोग न करें।

— otterslide 15

Answer 7

हमें हमेशा दो पूर्णांक के लिए तुलना के लिए बराबर () विधि के लिए जाना चाहिए। अनुशंसित अभ्यास को लागू करता है।

यदि हम == का उपयोग करके दो पूर्णांक की तुलना करते हैं, तो यह JVM के आंतरिक अनुकूलन के कारण पूर्णांक मानों की कुछ सीमा (पूर्णांक -128 से 127) के लिए काम करेगा।

कृपया उदाहरण देखें:

मामला एक:

पूर्णांक = 100; इंटेगर बी = 100;

if (a == b) {
    System.out.println("a and b are equal");
} else {
   System.out.println("a and b are not equal");
}

उपरोक्त मामले में, JVM कैश्ड पूल से a और b के मान का उपयोग करता है और पूर्णांक ऑब्जेक्ट का एक ही ऑब्जेक्ट उदाहरण (इसलिए मेमोरी एड्रेस) लौटाता है और हम दोनों को समान पाते हैं। कुछ ऑप्टिमाइज़ेशन JVM कुछ श्रेणी मानों के लिए ऑप्टिमाइज़ेशन करता है।

केस 2: इस मामले में, ए और बी बराबर नहीं हैं क्योंकि यह -128 से 127 तक की सीमा के साथ नहीं आता है।

पूर्णांक = 220; पूर्णांक बी = 220;

if (a == b) {
    System.out.println("a and b are equal");
} else {
   System.out.println("a and b are not equal");
}

सही तरीका:

Integer a = 200;             
Integer b = 200;  
System.out.println("a == b? " + a.equals(b)); // true

आशा है कि ये आपकी मदद करेगा।

Answer 8

मेरे मामले में मुझे Integerसमानता के लिए दो एस की तुलना करनी थी जहां दोनों हो सकते हैं null। इसी तरह के विषय की खोज की, इसके लिए कुछ भी सुंदर नहीं मिला। एक साधारण उपयोगिता कार्यों के साथ आया था।

public static boolean integersEqual(Integer i1, Integer i2) {
    if (i1 == null && i2 == null) {
        return true;
    }
    if (i1 == null && i2 != null) {
        return false;
    }
    if (i1 != null && i2 == null) {
        return false;
    }
    return i1.intValue() == i2.intValue();
}

//considering null is less than not-null
public static int integersCompare(Integer i1, Integer i2) {
    if (i1 == null && i2 == null) {
        return 0;
    }
    if (i1 == null && i2 != null) {
        return -1;
    }
    return i1.compareTo(i2);
}

Answer 9

क्योंकि कम्पैरिज़न मेथड सही ऑपरेटर के साथ टाइप इंट (x == y) या क्लास इंटेगर (x.equals (y)) के आधार पर किया जाना चाहिए

public class Example {

    public static void main(String[] args) {
     int[] arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<arr.length-1; j++)
            if((arr[j-1]!=arr[j]) && (arr[j]!=arr[j+1])) 
                System.out.println("int>"+arr[j]);


    Integer[] I_arr = {-32735, -32735, -32700, -32645, -32645, -32560, -32560};

        for(int j=1; j<I_arr.length-1; j++)
            if((!I_arr[j-1].equals(I_arr[j])) && (!I_arr[j].equals(I_arr[j+1]))) 
                System.out.println("Interger>"+I_arr[j]);
    }
}

Answer 10

यह विधि दो इंटर्गर की तुलना शून्य जांच के साथ करती है, परीक्षण देखें

public static boolean compare(Integer int1, Integer int2) {
    if(int1!=null) {
        return int1.equals(int2);
    } else {
        return int2==null;
    }
    //inline version:
    //return (int1!=null) ? int1.equals(int2) : int2==null;
}

//results:
System.out.println(compare(1,1));           //true
System.out.println(compare(0,1));           //false
System.out.println(compare(1,0));           //false
System.out.println(compare(null,0));        //false
System.out.println(compare(0,null));        //false
System.out.println(compare(null,null));     //true

Comments

इसके लिए, मुझे लगता है कि केवल Objects.equals(x,y)अपना रोल बनाने के बजाय विधि का उपयोग करना बेहतर होगा ।

— पुनर्वसु