जावा में == और बराबर () के बीच क्या अंतर है?

Question

अगर मैं इसे सही ढंग से समझता हूं तो मैं स्पष्ट करना चाहता था:

• == एक संदर्भ तुलना है, यानी दोनों ऑब्जेक्ट एक ही मेमोरी स्थान पर इंगित करते हैं
• .equals() वस्तुओं में मूल्यों की तुलना का मूल्यांकन करता है

Comments

हाँ, बहुत ज्यादा

— जॉन केन

हाँ, हाजिर। आप सार्थक.equals() रूप से बराबर के

— vikingsteve

के संभावित डुप्लिकेट मैं कैसे जावा में तार तुलना करते हैं?

— टायलरह

"दोनों ऑब्जेक्ट्स एक ही मेमोरी लोकेशन की ओर इशारा करते हैं" जैसा एक वाक्य मैला भाषा है, जो समझ को और अधिक कठिन बना सकता है। आपका मतलब है: "दोनों चर एक ही वस्तु को संदर्भित करते हैं"। ध्यान दें कि एक चर एक वस्तु नहीं है; एक चर एक वस्तु का एक संदर्भ है। ऑब्जेक्ट कुछ भी "इंगित नहीं" करते हैं।

— जेस्पर

Answer 1

सामान्य तौर पर, आपके प्रश्न का उत्तर "हां" है, लेकिन ...

• .equals(...) केवल तुलना करने के लिए लिखा है कि क्या तुलना करना है, और नहीं, कम नहीं।
• यदि कोई वर्ग समतुल्य विधि को ओवरराइड नहीं करता है, तो यह equals(Object o)निकटतम अभिभावक वर्ग की विधि के लिए चूक करता है जिसने इस पद्धति को ओवरराइड किया है।
• यदि कोई अभिभावक वर्ग ने एक ओवरराइड प्रदान नहीं किया है, तो यह अंतिम मूल वर्ग, ऑब्जेक्ट से विधि के लिए चूक करता है, और इसलिए आपको Object#equals(Object o)विधि के साथ छोड़ दिया जाता है । ऑब्जेक्ट API के अनुसार यह समान है ==; यह है, यह सच है अगर और अगर दोनों चर एक ही वस्तु को देखें, अगर उनके संदर्भ एक और समान हैं। इस प्रकार आप वस्तु समानता के लिए परीक्षण करेंगे और कार्यात्मक समानता नहीं ।
• हमेशा ओवरराइड करने के लिए याद रखें hashCodeयदि आप ओवरराइड करते हैं equalsतो "अनुबंध को तोड़ने" के लिए नहीं। एपीआई के अनुसार, hashCode()दो वस्तुओं के लिए विधि से लौटा हुआ परिणाम समान होना चाहिए यदि उनके equalsतरीके बताते हैं कि वे समकक्ष हैं। यह आवश्यक नहीं है कि अनुलोम विलोम हो।

Comments

यदि ==स्मृति संदर्भ के लिए जाँच की जाती है, तो मुझे यह [] [1] [१]: docs.google.com/document/d/… में अजीब व्यवहार मिल रहा है, मुझे उम्मीद है कि आउटपुट सही होगा। मेरे भ्रम को दूर कर सकते हैं

— JPG

@ जेएसके डी 1 और डी 2 के मूल्यों को प्रिंट करता है और मुझे लगता है कि आप देखेंगे कि आप झूठे क्यों लौट रहे हैं।

— BoDidely

@ मुझे लगता है कि यह समझ से बाहर है। ऐसा इसलिए था क्योंकि सभी रैपर कक्षाएं अपरिवर्तनीय हैं।

— JPG

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).<br/> Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.( docs.oracle.com/javase/7/docs/api/java/lang/… )

— अभिजीत

असंबंधित: आज मैंने निम्न गुणवत्ता वाले नौसिखियों के प्रश्नों पर टिप्पणी करते हुए अच्छे / प्रभावी / ... "ऑटो" संदेशों के संबंध में एक मेटा प्रश्न ( meta.stackoverflow.com/questions/372795/… ) डाला । मुझे मिली प्रतिक्रिया ने बहुत महसूस किया "आप पूरी तरह से गलत काम कर रहे हैं"। अब मैं बस सोच रहा हूं कि आप इसे कैसे देखते हैं? क्या आपके तरकश में "सामान्य" संदेश हैं, या क्या आप ऐसे मामलों में पूरी तरह से विशिष्ट टिप्पणियां लिखते हैं?

— घोस्टकट

Answer 2

स्ट्रिंग वर्ग के संबंध में:

बराबरी () विधि स्ट्रिंग मानों (ढेर पर) के अंदर "मान" की तुलना करती है, भले ही दो वस्तु संदर्भ एक ही स्ट्रिंग उदाहरण को देखें या नहीं। यदि स्ट्रिंग के किसी भी दो ऑब्जेक्ट संदर्भ एक ही स्ट्रिंग उदाहरण को देखें तो महान! यदि दो ऑब्जेक्ट संदर्भ दो अलग-अलग स्ट्रिंग उदाहरणों को संदर्भित करते हैं .. तो इससे कोई फर्क नहीं पड़ता। प्रत्येक स्ट्रिंग उदाहरण के अंदर "मान" (वह है: वर्ण सरणी की सामग्री) जिसकी तुलना की जा रही है।

दूसरी ओर, "==" ऑपरेटर दो ऑब्जेक्ट संदर्भों के मूल्य की तुलना करता है यह देखने के लिए कि क्या वे एक ही स्ट्रिंग उदाहरण को संदर्भित करते हैं । यदि दोनों ऑब्जेक्ट संदर्भों का मान "एक ही स्ट्रिंग उदाहरण" को संदर्भित करता है, तो बूलियन अभिव्यक्ति का परिणाम "सच" "डुह" होगा। यदि, दूसरी ओर, दोनों ऑब्जेक्ट संदर्भों का मान "" अलग-अलग स्ट्रिंग इंस्टेंसेस को संदर्भित करता है (भले ही दोनों स्ट्रिंग इंस्टेंस समान "मान" हैं, अर्थात, प्रत्येक स्ट्रिंग उदाहरण के वर्ण सरणियों की सामग्री समान हैं) बूलियन अभिव्यक्ति का परिणाम "गलत" होगा।

किसी भी स्पष्टीकरण के साथ, इसे अंदर डूबने दें।

मुझे उम्मीद है कि इससे चीजें थोड़ी साफ हो जाएंगी।

Comments

तो तार के लिए == संदर्भ बराबर है? यानी अन्य वस्तुओं के लिए के रूप में ही काम करता है?

— जोनिरा

(थ्रेड काला जादू, मुझे पता है ...) के लिए Stringहै, ==संदर्भ के रूप में अच्छी तरह से बराबर होती है, हाँ है, लेकिन यह आम तौर पर (दो में रूप में काम करता Stringएक ही सामग्री के साथ होगा आम तौर पर हो सकता है ==की वजह से कैसे जावा हैंडल, एक दूसरे के लिए) Stringएस। यह हमेशा नहीं होगा, और यह निश्चित रूप से बुरा अभ्यास है, लेकिन यह एक आम गलती है, खासकर अन्य भाषाओं से आने वाले लोगों से।

— टोनियो

टोनियो की टिप्पणी पर जोड़ने के लिए। Stringस्ट्रिंग शाब्दिक से बिल्ड को कुछ चीज़ों में जोड़ा जाएगा String constant pool, जैसे कि String s1 = "someString"; String s2 = "someString;"दोनों s1और s2एक ही संदर्भ साझा करेंगे। s1 == s2सच लौटेगा। लेकिन अगर वे के माध्यम से निर्माण किया गया था String constructor, उदाहरण के लिए String s1 = new String("someString"); String s2 = new String("someString");तो वे एक ही संदर्भ साझा नहीं करेंगे। s1 == s2झूठा लौटेगा।

— गैविन

Answer 3

आप "आदिम" या "ऑब्जेक्ट प्रकार" के बारे में बात कर रहे हैं या नहीं, इसके आधार पर कुछ छोटे अंतर हैं; यदि आप "स्थिर" या "गैर-स्थैतिक" सदस्यों के बारे में बात कर रहे हैं तो वही कहा जा सकता है; आप उपरोक्त सभी मिश्रण भी कर सकते हैं ...

यहाँ एक उदाहरण है (आप इसे चला सकते हैं):

public final class MyEqualityTest
{
    public static void main( String args[] )
    {
        String s1 = new String( "Test" );
        String s2 = new String( "Test" );

        System.out.println( "\n1 - PRIMITIVES ");
        System.out.println( s1 == s2 ); // false
        System.out.println( s1.equals( s2 )); // true

        A a1 = new A();
        A a2 = new A();

        System.out.println( "\n2 - OBJECT TYPES / STATIC VARIABLE" );
        System.out.println( a1 == a2 ); // false
        System.out.println( a1.s == a2.s ); // true
        System.out.println( a1.s.equals( a2.s ) ); // true

        B b1 = new B();
        B b2 = new B();

        System.out.println( "\n3 - OBJECT TYPES / NON-STATIC VARIABLE" );
        System.out.println( b1 == b2 ); // false
        System.out.println( b1.getS() == b2.getS() ); // false
        System.out.println( b1.getS().equals( b2.getS() ) ); // true
    }
}

final class A
{
    // static
    public static String s;
    A()
    {
        this.s = new String( "aTest" );
    }
}

final class B
{
    private String s;
    B()
    {
        this.s = new String( "aTest" );
    }

    public String getS()
    {
        return s;
    }

}

आप इन लिंक के माध्यम से "==" (समानता ऑपरेटर) और "। असमान (...)" (java.lang.Object वर्ग में विधि) के स्पष्टीकरण की तुलना कर सकते हैं:

• ==: http://docs.oracle.com/javase/tutorial/java/nutsandbolts/op2.html
• .equals (...): http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

Comments

दिलचस्प उदाहरण। उपरोक्त उत्तरों से अलग दृष्टिकोण। धन्यवाद!

— एंड्रयू

मेरी राय में सबसे अच्छा जवाब, क्योंकि यह स्पष्टीकरण को खोए बिना अन्य पूर्ण-पाठ उत्तरों की तुलना में स्पष्ट है (यदि आप वर्ग और स्थिर अवधारणाओं को देखते हैं, तो निश्चित रूप से)

— Carrm

Answer 4

== और बराबर के बीच का अंतर मुझे कुछ समय के लिए उलझन में डाल देता है जब तक कि मैंने इसे करीब से देखने का फैसला नहीं किया। उनमें से कई कहते हैं कि स्ट्रिंग की तुलना के लिए आपको उपयोग करना चाहिए equalsऔर नहीं ==। इस उत्तर में आशा है कि मैं अंतर कह सकूंगा।

इस सवाल का जवाब देने का सबसे अच्छा तरीका होगा कि आप खुद से कुछ सवाल पूछें। चलिए, शुरू करते हैं:

निम्न कार्यक्रम के लिए आउटपुट क्या है:

String mango = "mango";
String mango2 = "mango";
System.out.println(mango != mango2);
System.out.println(mango == mango2);

अगर आप कहते हैं,

false
true

मैं कहूंगा कि आप सही हैं लेकिन आपने ऐसा क्यों कहा ? और अगर आप कहते हैं कि आउटपुट है,

true
false

मैं कहूंगा कि आप गलत हैं लेकिन मैं फिर भी आपसे पूछूंगा कि आप ऐसा क्यों सोचते हैं?

ठीक है, चलो यह जवाब देने की कोशिश करते हैं:

निम्न कार्यक्रम के लिए आउटपुट क्या है:

String mango = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango3);
System.out.println(mango == mango3);

अब अगर आप कहें,

false
true

मैं कहूंगा कि आप गलत हैं लेकिन अब यह गलत क्यों है ? इस कार्यक्रम के लिए सही आउटपुट है

true
false

कृपया उपरोक्त कार्यक्रम की तुलना करें और इसके बारे में सोचने का प्रयास करें।

ठीक है। अब यह मदद कर सकता है (कृपया इसे पढ़ें: ऑब्जेक्ट का पता प्रिंट करें - संभव नहीं है लेकिन फिर भी हम इसका उपयोग कर सकते हैं।)

String mango = "mango";
String mango2 = "mango";
String mango3 = new String("mango");
System.out.println(mango != mango2);
System.out.println(mango == mango2);
System.out.println(mango3 != mango2);
System.out.println(mango3 == mango2);
// mango2 = "mang";
System.out.println(mango+" "+ mango2);
System.out.println(mango != mango2);
System.out.println(mango == mango2);

System.out.println(System.identityHashCode(mango));
System.out.println(System.identityHashCode(mango2));
System.out.println(System.identityHashCode(mango3));

क्या आप ऊपर दिए गए कोड में अंतिम तीन पंक्तियों के आउटपुट के बारे में सोचने की कोशिश कर सकते हैं: मेरे लिए ideone ने इसे प्रिंट किया है ( आप यहां कोड की जांच कर सकते हैं ):

false
true
true
false
mango mango
false
true
17225372
17225372
5433634

ओह! अब आप देखते हैं कि पहचानहेडकोड ​​(आम) पहचान के बराबर है। हाशकोड (आम 2) लेकिन यह पहचान के बराबर नहीं है।

भले ही सभी स्ट्रिंग चर - आम, मैंगो 2 और मैंगो 3 - का समान मूल्य है, जो "आम" है, फिर identityHashCode()भी सभी के लिए समान नहीं है।

अब इस पंक्ति को अनसुना करने का प्रयास करें // mango2 = "mang";और इसे फिर से चलाएं इस बार आप देखेंगे कि तीनों identityHashCode()अलग-अलग हैं। हम्म जो एक सहायक संकेत है

हम जानते हैं कि अगर hashcode(x)=Nऔर hashcode(y)=N=>x is equal to y

मुझे यकीन नहीं है कि जावा आंतरिक रूप से कैसे काम करता है, लेकिन मुझे लगता है कि जब मैंने कहा तो यही हुआ:

mango = "mango";

जावा ने एक स्ट्रिंग बनाई "mango"जो कि चर (संदर्भित) mangoकुछ इस तरह से थी

mango ----> "mango"

अब अगली पंक्ति में जब मैंने कहा:

mango2 = "mango";

यह वास्तव में उसी स्ट्रिंग को पुन: उपयोग करता है "mango"जो कुछ इस तरह दिखता है

mango ----> "mango" <---- mango2

आम और आम 2 दोनों एक ही संदर्भ की ओर इशारा करते हैं। अब जब मैंने कहा

mango3 = new String("mango")

इसने वास्तव में "आम" के लिए एक पूरी तरह से नया संदर्भ (स्ट्रिंग) बनाया। जो कुछ इस तरह दिखता है,

mango -----> "mango" <------ mango2

mango3 ------> "mango"

और इसीलिए जब मैंने मूल्यों को mango == mango2रखा, तो इसे बाहर रखा true। और जब मैंने इसके लिए मूल्य mango3 == mango2रखा, तो इसे बाहर रखा false(तब भी जब मूल्य समान थे)।

और जब आपने लाइन को अनकंफर्ट किया तो // mango2 = "mang"; यह वास्तव में एक स्ट्रिंग "मंगल" बना, जिसने हमारा ग्राफ इस तरह से बदल दिया:

mango ---->"mango"
mango2 ----> "mang"
mango3 -----> "mango"

यही कारण है कि पहचानहैशकोड सभी के लिए समान नहीं है।

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

Comments

क्या mango == mango2ऐसा होता है क्योंकि आपने mango2 एक नई स्ट्रिंग ऑब्जेक्ट के रूप में नहीं बनाया , और इसके बजाय सीधे सीधे संदर्भित "mango"?

— बर्ट

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

— om252345

Answer 5

== कि क्या दो चर ऑपरेटर परीक्षण है (एक स्मृति पते पर सूचक उर्फ) एक ही संदर्भ ।

String foo = new String("abc");
String bar = new String("abc");

if(foo==bar)
// False (The objects are not the same)

bar = foo;

if(foo==bar)
// True (Now the objects are the same)

जहांकि बराबरी () विधि परीक्षण करती है कि क्या दो चर उन वस्तुओं को संदर्भित करते हैं जिनकी एक ही स्थिति (मान) है ।

String foo = new String("abc");
String bar = new String("abc");

if(foo.equals(bar))
// True (The objects are identical but not same)

चियर्स :-)

Comments

गलत। अगर (foo == बार) यह सच होना चाहिए तो गलत नहीं। यह एक ही स्ट्रिंग "एडीसी" का पुन: उपयोग करेगा। इसे सैंडबॉक्स में टेस्ट करें, यह दोनों के लिए सही होगा।

— जॉनाथन लोगन

@JohnathanLogan मुझे लगता है कि यह स्ट्रिंग इंटर्निंग के कारण है। अब मैं "नया स्ट्रिंग (" एबीसी ") में बदल गया हूं। आशा है कि अब कोई समस्या नहीं होगी। सूचित करने के लिए धन्यवाद।

— मोहनराज बालसुब्रमण्यम

Answer 6

आपको कस्टम कक्षाओं के साथ इसका उपयोग करने के लिए समान फ़ंक्शन (अन्य के साथ) को ओवरराइड करना होगा।

बराबर विधि वस्तुओं की तुलना करती है।

==द्विआधारी ऑपरेटर स्मृति पतों तुलना करती है।

Answer 7

यदि आप ओवरराइड नहीं करते हैं तो दोनों == और .equals () एक ही ऑब्जेक्ट को संदर्भित करता है।।

यह आपकी इच्छा है कि आप एक बार जब आप ओवरराइड करना चाहते हैं। आप वस्तु की स्थिति में पारित वस्तु के साथ आक्रामक वस्तु की स्थिति की तुलना कर सकते हैं या आप सिर्फ सुपर। असल्स () कह सकते हैं

Answer 8

==एक ऑपरेटर है और equals()एक विधि है ।

ऑपरेटर आमतौर पर आदिम प्रकार की तुलना के लिए उपयोग किए जाते हैं और इस प्रकार ==इसका उपयोग मेमोरी एड्रेस की तुलना के equals()लिए किया जाता है और वस्तुओं की तुलना के लिए विधि का उपयोग किया जाता है ।

Answer 9

 String w1 ="Sarat";
 String w2 ="Sarat";
 String w3 = new String("Sarat");

 System.out.println(w1.hashCode());   //3254818
 System.out.println(w2.hashCode());   //3254818
 System.out.println(w3.hashCode());   //3254818

 System.out.println(System.identityHashCode(w1)); //prints 705927765
 System.out.println(System.identityHashCode(w2)); //prints 705927765
 System.out.println(System.identityHashCode(w3)); //prints 366712642


 if(w1==w2)   //  (705927765==705927765)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

 if(w2==w3)   //  (705927765==366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints false


 if(w2.equals(w3))   //  (Content of 705927765== Content of 366712642)
 {
   System.out.println("true");
 }
 else
 {
   System.out.println("false");
 }
 //prints true

Comments

सरल और सबसे अच्छा स्पष्टीकरण

— श्रीतम जगदेव

Answer 10

बस याद रखें कि .equals(...)जिस कक्षा को आप तुलना करने की कोशिश कर रहे हैं, उसे लागू करना होगा। अन्यथा, वहाँ एक बिंदु से ज्यादा नहीं है; ऑब्जेक्ट क्लास के लिए विधि का संस्करण तुलनात्मक ऑपरेशन के समान कार्य करता है: ऑब्जेक्ट # बराबर होता है ।

केवल समय जब आप वास्तव में वस्तुओं के लिए तुलना ऑपरेटर का उपयोग करना चाहते हैं, तो आप Enums की तुलना कर रहे हैं। ऐसा इसलिए है क्योंकि एक समय में एक Enum मान का केवल एक उदाहरण है। उदाहरण के लिए, एनम दिया गया

enum FooEnum {A, B, C}

आपके पास Aएक समय में एक से अधिक उदाहरण नहीं होंगे , और उसी के लिए Bऔर C। इसका मतलब है कि आप वास्तव में इस तरह से एक विधि लिख सकते हैं:

public boolean compareFoos(FooEnum x, FooEnum y)
{
    return (x == y);
}

और आपको कोई समस्या नहीं होगी।

Answer 11

जब आप कोड का मूल्यांकन करते हैं, तो यह बहुत स्पष्ट है कि (==) मेमोरी पते के अनुसार तुलना करता है, जबकि बराबर (ऑब्जेक्ट ओ) उदाहरणों के हैशकोड () की तुलना करता है। इसीलिए यह कहा जाता है कि यदि आप बाद में आश्चर्य का सामना नहीं करते हैं तो बराबर () और हैशकोड () के बीच के अनुबंध को न तोड़ें।

    String s1 = new String("Ali");
    String s2 = new String("Veli");
    String s3 = new String("Ali");

    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());


    System.out.println("(s1==s2):" + (s1 == s2));
    System.out.println("(s1==s3):" + (s1 == s3));


    System.out.println("s1.equals(s2):" + (s1.equals(s2)));
    System.out.println("s1.equal(s3):" + (s1.equals(s3)));


    /*Output 
    96670     
    3615852
    96670
    (s1==s2):false
    (s1==s3):false
    s1.equals(s2):false
    s1.equal(s3):true
    */

Answer 12

यहाँ relational operator ==और के बीच के अंतर के लिए एक सामान्य नियम है the method .equals()।

object1 == object2यदि ऑब्जेक्ट ऑब्जेक्ट 1 और ऑब्जेक्ट 2 द्वारा संदर्भित ऑब्जेक्ट्स की तुलना करता है तो वह हीप में उसी मेमोरी लोकेशन को संदर्भित करता है ।

object1.equals(object2)ऑब्जेक्ट 1 और ऑब्जेक्ट 2 के मूल्यों की तुलना करता है, भले ही वे स्मृति में स्थित हों ।

यह स्ट्रिंग का उपयोग करके अच्छी तरह से प्रदर्शित किया जा सकता है

दृष्टांत 1

 public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = new String("Hello");
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

 }



The result is
      is str1 == str2 ? false
      is str1.equals(str2) ? true 

दृश्य २

public class Conditionals {

    public static void main(String[] args) {
       String str1 = "Hello";
       String str2 = "Hello";
       System.out.println("is str1 == str2 ? " + (str1 == str2 ));
       System.out.println("is str1.equals(str2) ? " + (str1.equals(str2 )));
    }

}

The result is 
  is str1 == str2 ? true
  is str1.equals(str2) ? true

इस स्ट्रिंग तुलना को अन्य प्रकार की वस्तु की तुलना के लिए एक आधार के रूप में इस्तेमाल किया जा सकता है।

उदाहरण के लिए यदि मेरे पास एक व्यक्ति वर्ग है , तो मुझे मापदंड आधार को परिभाषित करने की आवश्यकता है, जिस पर मैं दो व्यक्तियों की तुलना करूंगा । मान लीजिए कि इस व्यक्ति वर्ग में ऊंचाई और वजन के उदाहरण चर हैं।

इसलिए व्यक्ति वस्तुओं का निर्माण person1 and person2और इन दोनों की तुलना करने के लिए .equals()मुझे व्यक्ति वर्ग के बराबर विधि को ओवरराइड करने की आवश्यकता है चर (हेट या वजन) के आधार पर परिभाषित करने वह तुलना होगी।

हालाँकि, द == operator will still return results based on the memory location of the two objects(person1 and person2)।

इस व्यक्ति वस्तु तुलना की सामान्यता में आसानी के लिए, मैंने निम्नलिखित परीक्षण वर्ग बनाया है। इन अवधारणाओं पर प्रयोग करने से कई तथ्य सामने आएंगे ।

package com.tadtab.CS5044;

public class Person {

private double height;
private double weight;

public double getHeight() {
    return height;
}

public void setHeight(double height) {
    this.height = height;
}

public double getWeight() {
    return weight;
}

public void setWeight(double weight) {
    this.weight = weight;
}


@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    long temp;
    temp = Double.doubleToLongBits(height);
    result = prime * result + (int) (temp ^ (temp >>> 32));
    return result;
}

@Override
/**
 * This method uses the height as a means of comparing person objects.
 * NOTE: weight is not part of the comparison criteria
 */
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (Double.doubleToLongBits(height) != Double.doubleToLongBits(other.height))
        return false;
    return true;
}

public static void main(String[] args) {

    Person person1 = new Person();
    person1.setHeight(5.50);
    person1.setWeight(140.00);

    Person person2 = new Person();
    person2.setHeight(5.70);
    person2.setWeight(160.00);

    Person person3 = new Person();
    person3 = person2;

    Person person4 = new Person();
    person4.setHeight(5.70);

    Person person5 = new Person();
    person5.setWeight(160.00);

    System.out.println("is person1 == person2 ? " + (person1 == person2)); // false;
    System.out.println("is person2 == person3 ? " + (person2 == person3)); // true 
    //this is because perosn3 and person to refer to the one person object in memory. They are aliases;
    System.out.println("is person2.equals(person3) ? " + (person2.equals(person3))); // true;

    System.out.println("is person2.equals(person4) ? " + (person2.equals(person4))); // true;

    // even if the person2 and person5 have the same weight, they are not equal.
    // it is because their height is different
    System.out.println("is person2.equals(person4) ? " + (person2.equals(person5))); // false;
}

}

इस वर्ग के निष्पादन का परिणाम है:

is person1 == person2 ? false
is person2 == person3 ? true
is person2.equals(person3) ? true
is person2.equals(person4) ? true
is person2.equals(person4) ? false

Answer 13

यह भी ध्यान दें कि .equals()आम तौर पर ==परीक्षण के लिए होता है क्योंकि यह पहली चीज है जिसे आप परीक्षण करना चाहते हैं यदि आप दो वस्तुओं के बराबर होने पर परीक्षण करना चाहते हैं।

और ==वास्तव में आदिम प्रकारों के लिए मूल्यों को देखता है, वस्तुओं के लिए यह संदर्भ की जांच करता है।

Answer 14

== ऑपरेटर हमेशा संदर्भ की तुलना की जाती है। लेकिन के मामले में

बराबर () विधि

यह लागू होने पर निर्भर करता है यदि हम ओवरराइड विधि से ऑब्जेक्ट की तुलना में ऑब्जेक्ट की तुलना में ओवरराइड समान विधि हैं।

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//fasle
      obj==obj1 // fasle
    }
 }

उपरोक्त कोड में obj और obj1 ऑब्जेक्ट दोनों में समान डेटा होता है, लेकिन संदर्भ समान नहीं होता है, इसलिए झूठी और == भी बराबर होती है। लेकिन अगर हमने इससे ज्यादा की बराबरी की है

 class A
 {
   int id;
   String str;

     public A(int id,String str)
     {
       this.id=id;
       this.str=str;
     }
    public boolean equals(Object obj)
    {
       A a1=(A)obj;
      return this.id==a1.id;
    }

    public static void main(String arg[])
    {
      A obj=new A(101,"sam");
      A obj1=new A(101,"sam");

      obj.equals(obj1)//true
      obj==obj1 // fasle
    }
 }

पता करें कि यह उसी स्थिति के लिए सही और गलत होगा, जब हमने ओवरराइड किया था

बराबरी का तरीका।

यह ऑब्जेक्ट के मूल (आईडी) पर ऑब्जेक्ट की तुलना करता है

लेकिन ==

अभी भी वस्तु के संदर्भों की तुलना करें।

Answer 15

== और बराबर () के बीच प्रमुख अंतर है

1) == का उपयोग आदिमों की तुलना करने के लिए किया जाता है।

उदाहरण के लिए :

        String string1 = "Ravi";
        String string2 = "Ravi";
        String string3 = new String("Ravi");
        String string4 = new String("Prakash");

        System.out.println(string1 == string2); // true because same reference in string pool
        System.out.println(string1 == string3); // false

2) वस्तुओं की तुलना करने के लिए बराबर () का उपयोग किया जाता है। उदाहरण के लिए :

        System.out.println(string1.equals(string2)); // true equals() comparison of values in the objects
        System.out.println(string1.equals(string3)); // true
        System.out.println(string1.equals(string4)); // false

Answer 16

==कई ऑब्जेक्ट प्रकारों में उपयोग किया जा सकता है, लेकिन आप Object.equalsकिसी भी प्रकार, विशेष रूप से स्ट्रिंग्स और Google मानचित्र मार्कर के लिए उपयोग कर सकते हैं ।

Answer 17

public class StringPool {

public static void main(String[] args) {

    String s1 = "Cat";// will create reference in string pool of heap memory
    String s2 = "Cat";
    String s3 = new String("Cat");//will create a object in heap memory

    // Using == will give us true because same reference in string pool

    if (s1 == s2) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using == with reference and Object will give us False

    if (s1 == s3) {
        System.out.println("true");
    } else {
        System.out.println("false");
    }

    // Using .equals method which refers to value

    if (s1.equals(s3)) {
        System.out.println("true");
    } else {
        System.out.println("False");
    }

    }
  }

---- आउटपुट ----- सच्चा झूठा सच

Answer 18

यह जोड़ने योग्य हो सकता है कि आदिम प्रकारों के लिए आवरण ऑब्जेक्ट्स के लिए - यानी इंट, लॉन्ग, डबल - == दोनों मान समान होने पर वापस लौट आएंगे।

Long a = 10L;
Long b = 10L;

if (a == b) {
    System.out.println("Wrapped primitives behave like values");
}

इसके विपरीत, उपरोक्त दो लोंगों को दो अलग-अलग ArrayLists में डालकर, उन्हें समान रूप से देखता है, लेकिन == नहीं।

ArrayList<Long> c = new ArrayList<>();
ArrayList<Long> d = new ArrayList<>();

c.add(a);
d.add(b);
if (c == d) System.out.println("No way!");
if (c.equals(d)) System.out.println("Yes, this is true.");

Comments

आदिम प्रकारों के लिए आवरण की वस्तुएं - यानी इंटेगर, लॉन्ग, डबल == भले ही दो मूल्यों के बराबर होने पर भी सही न हो। यह पूरी तरह से रैपर के कैश पर निर्भर करता है। नीचे कोड गलत होगा क्योंकि डिफ़ॉल्ट कैश -128 से 127 तक सीमित है। Long a = 128l; Long b = 128l; System.out.println(a == b);

— नीतेश भारद्वाज

Answer 19

स्ट्रिंग पूल (उर्फ होना शामिल है) और पूर्णांक पूल कलंक आगे अंतर है, और आप का उपयोग करने के लिए अनुमति दे सकता ==बजाय कुछ मामलों में वस्तुओं के लिए.equals

यह आपको अधिक जटिलता की लागत पर अधिक प्रदर्शन (?) दे सकता है।

उदाहरण के लिए:

assert "ab" == "a" + "b";

Integer i = 1;
Integer j = i;
assert i == j;

जटिलता व्यापार: निम्नलिखित आपको आश्चर्यचकित कर सकता है:

assert new String("a") != new String("a");

Integer i = 128;
Integer j = 128;
assert i != j;

मैं आपको ऐसे माइक्रो-ऑप्टिमाइज़ेशन से दूर रहने की सलाह देता हूँ, और हमेशा.equals वस्तुओं के लिए, और ==आदिम लोगों के लिए उपयोग करता हूँ :

assert (new String("a")).equals(new String("a"));

Integer i = 128;
Integer j = 128;
assert i.equals(j);

Answer 20

संक्षेप में, उत्तर "हां" है।

जावा में, ==ऑपरेटर दो वस्तुओं की तुलना यह देखने के लिए करता है कि क्या वे एक ही मेमोरी लोकेशन की ओर इशारा करते हैं; जबकि .equals()विधि वास्तव में दो वस्तुओं की तुलना करके यह देखने के लिए है कि क्या उनके पास समान वस्तु मूल्य है।

Answer 21

मूल रूप से, == तुलना करता है कि दो वस्तुओं के ढेर पर एक ही संदर्भ है, इसलिए जब तक दो संदर्भ एक ही वस्तु से जुड़े नहीं हैं, यह तुलना झूठी होगी।

equals()Objectकक्षा से विरासत में मिली एक विधि है । यह विधि डिफ़ॉल्ट रूप से तुलना करती है यदि दो वस्तुओं में एक ही रेफरी हो। इसका मतलब:

object1.equals(object2) <=> object1 == object2

हालाँकि, यदि आप एक ही वर्ग की दो वस्तुओं के बीच समानता स्थापित करना चाहते हैं, तो आपको इस पद्धति को ओवरराइड करना चाहिए। hashCode()यदि आपके पास ओवरराइड है, तो विधि को ओवरराइड करना भी बहुत महत्वपूर्ण हैequals() ।

hashCode()समानता स्थापित करते समय कार्यान्वयन जावा ऑब्जेक्ट कॉन्ट्रैक्ट का हिस्सा है। यदि आप संग्रह के साथ काम कर रहे हैं, और आपने लागू नहीं किया है hashCode(), तो स्ट्रेंज बैड थिंग्स हो सकता है:

HashMap<Cat, String> cats = new HashMap<>();
Cat cat = new Cat("molly");
cats.put(cat, "This is a cool cat");
System.out.println(cats.get(new Cat("molly"));

nullयदि आपने लागू नहीं किया है तो पिछले कोड को निष्पादित करने के बाद मुद्रित किया जाएगा hashCode()।

Answer 22

चूंकि जावा ऑपरेटर ओवरलोडिंग का समर्थन नहीं करता है, == हर वस्तु के लिए समान व्यवहार करता है लेकिन बराबर () विधि है, जिसे जावा में ओवरराइड किया जा सकता है और वस्तुओं की तुलना करने के लिए तर्क को व्यावसायिक नियमों के आधार पर बदला जा सकता है।

जावा में == और बराबर के बीच मुख्य अंतर यह है कि "==" का उपयोग आदिमों की तुलना करने के लिए किया जाता है जबकि वस्तुओं की समानता की जांच करने के लिए बराबर () विधि की सिफारिश की जाती है।

स्ट्रिंग तुलना = = और समान विधि दोनों का उपयोग करने का एक सामान्य परिदृश्य है। चूंकि java.lang.String वर्ग ओवरराइड विधि के बराबर है, यह सही है अगर दो स्ट्रिंग ऑब्जेक्ट में समान सामग्री है, लेकिन == केवल तभी वापस आ जाएगी जब दो संदर्भ एक ही ऑब्जेक्ट की ओर इशारा कर रहे हों।

यहाँ == और बराबर () पद्धति का उपयोग करके समानता के लिए जावा में दो स्ट्रिंग्स की तुलना करने का एक उदाहरण है जो कुछ संदेह को स्पष्ट करेगा:

public class TEstT{

    public static void main(String[] args) {

String text1 = new String("apple");
String text2 = new String("apple");

//since two strings are different object result should be false
boolean result = text1 == text2;
System.out.println("Comparing two strings with == operator: " + result);

//since strings contains same content , equals() should return true
result = text1.equals(text2);
System.out.println("Comparing two Strings with same content using equals method: " + result);

text2 = text1;
//since both text2 and text1d reference variable are pointing to same object
//"==" should return true
result = (text1 == text2);
System.out.println("Comparing two reference pointing to same String with == operator: " + result);

}
}