स्ट्रिंग # समतुल्य और स्ट्रिंग # contentEquals विधियों के बीच अंतर

152

String#equalsविधि और विधि के बीच अंतर क्या है String#contentEquals?

java string equality

— Arathana
स्रोत

171

String#equals()न केवल स्ट्रिंग की सामग्री, लेकिन यह भी चेकों तुलना करता है, तो अन्य वस्तु भी एक का एक उदाहरण है String। String#contentEquals()केवल सामग्री (वर्ण अनुक्रम) तुलना करता है और करता नहीं की जाँच करता है, तो अन्य वस्तु भी का एक उदाहरण है String। यह लंबे समय के रूप में कुछ भी हो सकता है के रूप में यह एक कार्यान्वयन की है CharSequenceAo को शामिल किया गया है जो String, StringBuilder, StringBuffer, CharBuffer, आदि

— BalusC
स्रोत

12

तो, क्या यह ऑपरेटरों ==(सामग्री) और ===जावास्क्रिप्ट में (बराबर) की तरह है?

— 19

2

@anestv जावा में, ==ऑपरेटर आपको केवल दो वस्तुओं की सामग्री के संदर्भ की तुलना करने की अनुमति देगा ।

— Stephan

2

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

— ला-कोमाद्रेजा

2

@ स्टेफ़न, ==उल्लेख केवल जावास्क्रिप्ट है; यह जावा के संबंध में कभी उल्लेख नहीं किया गया है।

— ओलाथे

@anestv, अंतर हैं ( ==जावास्क्रिप्ट में तुलना में बहुत कम है contentEquals, जो संख्या को नहीं छूएगा, उदाहरण के लिए), लेकिन आप equalsसटीक प्रकार के मिलान के साथStrings जांच करने के बारे में सही हैं (अन्य वर्ग उनके equalsतरीकों के प्रकारों के साथ शिथिल हो सकते हैं ) ।

— ओलाथे

43

इसे आसानी से रखा जा सकता है: String.contentEquals()यह होशियार भाई है String.equals(), क्योंकि यह कार्यान्वयन से अधिक मुक्त हो सकता है String.equals()।

अलग-अलग String.contentEquals()विधि होने के कुछ कारण हैं । मुझे लगता है कि सबसे महत्वपूर्ण कारण है:

equalsविधि कर्मकर्त्ता हो गया है। इसका मतलब है कि x.equals(y) == y.equals(x):। इसका तात्पर्य है कि aString.equals(aStringBuffer)जैसा होना होगा वैसा ही होगा aStringBuffer.equals(aString)। इसके लिए जावा एपीआई डेवलपर्स को स्ट्रिंगबफर, स्ट्रिंगबर्ल equals()और चारसेंसेंस की विधि में स्ट्रिंग्स के लिए कुछ विशेष कार्यान्वयन करने की आवश्यकता होगी । यह एक गड़बड़ होगी।

यह जहां है String.contentEqualsमें आता है। यह एक है स्टैंडअलोन विधि है कि नहीं करने के लिए है सख्त आवश्यकताओं और नियमों के पालन के लिए Object.equals। इस तरह, आप "समान सामग्री" की भावना को और अधिक स्वतंत्र रूप से लागू कर सकते हैं । यह आपको एक StringBuffer और एक स्ट्रिंग के बीच बुद्धिमान तुलना करने की अनुमति देता है, उदाहरण के लिए।

और यह कहने के लिए कि वास्तव में क्या अंतर है:

String.contentEquals()इनमें से एक String, एक StringBuilder, एक StringBuffer, एक CharSequenceऔर सभी व्युत्पन्न वर्गों की सामग्री की तुलना कर सकते हैं । यदि पैरामीटर स्ट्रिंग का प्रकार है, तो String.equals()निष्पादित करें।
String.equals()केवल स्ट्रिंग वस्तुओं की तुलना करता है। अन्य सभी ऑब्जेक्ट प्रकार को समान नहीं माना जाता है।
String.contentEquals()तुलना कर सकते हैं StringBufferऔर StringBuilderएक बुद्धिमान तरीके से। यह भारी विधि को नहीं कहता है toString(), जो पूरी सामग्री को एक नई स्ट्रिंग ऑब्जेक्ट में कॉपी करता है। इसके बजाय, यह अंतर्निहित char[]सरणी के साथ तुलना करता है, जो महान है।

— मार्टिज़न कोर्टको
स्रोत

31

यह उत्तर पहले से ही dbw द्वारा पोस्ट किया गया था, लेकिन उन्होंने इसे हटा दिया लेकिन उनके पास निष्पादन समय की तुलना करते समय अंतर के लिए कुछ बहुत ही मान्य बिंदु थे, क्या अपवाद फेंके गए हैं,

यदि आप स्रोत कोड स्ट्रिंग # बराबरी और स्ट्रिंग # contentEquals को देखते हैं तो यह स्पष्ट है कि String#contentEqualsएक के लिए दो ओवरराइड तरीके हैं जो लेते हैं StringBuilderऔर अन्य CharSequence।
उनके बीच का अंतर,

String#contentEqualsअगर तर्क दिया गया है तो NPE फेंक देंगे, nullलेकिन String#equalsवापस आ जाएगाfalse
String#equalsसामग्री की तुलना केवल तब की जाती है जब आपूर्ति की गई तर्क instance of Stringअन्यथा यह falseअन्य सभी मामलों में वापस आ जाएगी, लेकिन दूसरी तरफ String#contentEqualsउन सभी वस्तुओं की सामग्री की जांच करता है जो इंटरफ़ेस को लागू करते हैं CharSequence।

आप कोड को भी बदल सकते हैं ताकि String#contentEqualsगलत परिणाम लौटाएं या परिणाम जो आप equalsनीचे दिए गए तर्क के तरीके को ओवरराइड करके चाहते हैं जैसा कि नीचे दिखाया गया है, लेकिन आप उन ट्वीक के साथ नहीं कर सकते String#equals।
नीचे कोड हमेशाtrue तब तक उत्पन्न होगा जब तक कि sकोई भी stringवर्ण जो 3 वर्ण लंबा हो

    String s= new String("abc");// "abc";
    System.out.println(s.contentEquals(new CharSequence() 
    {

        @Override
        public CharSequence subSequence(int arg0, int arg1) {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public int length() {
            // TODO Auto-generated method stub
            return 0;
        }

        @Override
        public char charAt(int arg0) {
            // TODO Auto-generated method stub
            return 0;
        }


        @Override
        public boolean equals(Object obj) 
        {
           return true;
        }
    }));

String#contentEqualsतब धीमी हो जाएगी String#Equalsजब मामले में तर्क दिया जाएगा instance of Stringऔर दोनों की लंबाई Stringसमान है लेकिन सामग्री समान नहीं है।
उदाहरण यदि स्ट्रिंग हैं String s = "madam"और String argPassed = "madan"तब s.contentEquals(argPassed)की तुलना में इस मामले में लगभग डबल निष्पादन समय लगेगाs.equals(argPassed)
यदि सामग्री की लंबाई दोनों स्ट्रिंग्स के लिए समान नहीं है, तो फ़ंक्शन String#contentEqualsका प्रदर्शन बेहतर होगा तो String#Equalsलगभग सभी संभव मामलों में।

एक और बात उसके जवाब में जोड़ने के लिए

String#contentEqualsएक Stringवस्तु भी StringBuilderसामग्री की तुलना करेगी और String#Equalsवापसी करते समय उचित परिणाम प्रदान करेगीfalse

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

4

@ यह उत्तर आपके द्वारा पोस्ट किए गए उत्तर से है

— Prateek

@dbw इसके अलावा, आपने अपनी पोस्ट को फिर भी क्यों हटाया?

— एमसी सम्राट

14

Stringवर्ग equals(Object o)विधि केवल Stringतुलना करती है। लेकिन contentEquals(CharSequence cs)कक्षाओं के लिए जाँच करता है फैली हुई है AbstractStringBuilderयानी StringBuffer, StringBuilderऔर Stringवर्ग भी (वे सभी प्रकार के होते हैं CharSequence)।
```
String str = "stackoverflow";
StringBuilder builder = new StringBuilder(str);
System.out.println(str.equals(builder));
System.out.println(str.contentEquals(builder));
```

उत्पादन:

false
true

पहले stmt के उत्पादन में है falseक्योंकि builderके प्रकार नहीं है Stringतो equals()रिटर्न falseलेकिन contentEquals()जैसे सभी प्रकार की सामग्री के लिए जाँच करता है StringBuilder, StringBuffer, Stringऔर के रूप में सामग्री एक ही इसलिए है true।

contentEqualsNullPointerExceptionअगर तर्क दिया गया है तो फेंक देंगे , nullलेकिन equals()झूठा वापस आ जाएगा क्योंकि बराबर () उदाहरण के लिए जाँच करता है ( if (anObject instance of String)अगर) तर्क है जो झूठा लौटता है null।

— कोशिश कर रहे हैं
स्रोत

14

contentEquals(CharSequence cs):

आप इंटरफेस के किसी भी कार्यान्वयन उदाहरण के साथ दिया स्ट्रिंग मान की समानता की जांच की सुविधा देता है java.lang.CharacterSequence(जैसे, CharBuffer, Segment, String, StringBuffer, StringBuilder)

equals(Object anObject):

आपको दिए गए स्ट्रिंग मान की समानता को केवल किसी भी प्रकार के उदाहरण से जांचने देता हैjava.lang.String

RTFC :)

चूंकि स्रोत को पढ़ना सबसे अच्छा तरीका है, इसे समझने के लिए, मैं दोनों तरीकों के कार्यान्वयन को साझा कर रहा हूं (jdk 1.7.245 के अनुसार)

public boolean contentEquals(CharSequence cs) {
    if (value.length != cs.length())
        return false;
    // Argument is a StringBuffer, StringBuilder
    if (cs instanceof AbstractStringBuilder) {
        char v1[] = value;
        char v2[] = ((AbstractStringBuilder) cs).getValue();
        int i = 0;
        int n = value.length;
        while (n-- != 0) {
            if (v1[i] != v2[i])
                return false;
            i++;
        }
        return true;
    }
    // Argument is a String
    if (cs.equals(this))
        return true;
    // Argument is a generic CharSequence
    char v1[] = value;
    int i = 0;
    int n = value.length;
    while (n-- != 0) {
        if (v1[i] != cs.charAt(i))
            return false;
        i++;
    }
    return true;
}

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String) anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                        return false;
                i++;
            }
            return true;
        }
    }
    return false;
 }

स्ट्रिंग # contentEquals () की एक और विधि है:

public boolean contentEquals(StringBuffer sb) {
    synchronized(sb) {
        return contentEquals((CharSequence)sb);
    }
}

— अमित शर्मा
स्रोत

9

equals()और दो और साथ की तुलना करने के लिए कक्षा contentEquals()में दो विधियाँ हैं ।StringstringsstringStringBuffer

के पैरामीटर contentEquals()हैं StringBufferऔर String(charSequence)। equals()दो की तुलना करने के लिए प्रयोग किया जाता है stringsऔर contentEquals()की सामग्री की तुलना करने के लिए उपयोग किया जाता है Stringऔर StringBuffer।

विधि contentEqualsऔर equalsहैं

public boolean contentEquals(java.lang.StringBuffer);
public boolean contentEquals(java.lang.CharSequence);
public boolean equals(Object o)

यहाँ एक कोड है जो दोनों विधियों का वर्णन करता है

public class compareString {
    public static void main(String[] args) {
        String str1 = "hello";    
        String str2 = "hello";

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");

        boolean result1 = str1.equals(str2);        // works nice and returns true
        System.out.println(" str1.equals(str2) - "+ result1);

        boolean result2 = str1.equals(sb1);         // works nice and returns false
        System.out.println(" str1.equals(sb1) - "+ result2);

        boolean result3 = str1.contentEquals(sb1);  // works nice and returns true
        System.out.println(" str1.contentEquals(sb1) - "+ result3);

        boolean result4 = str1.contentEquals(sb2);  // works nice and returns false
        System.out.println(" str1.contentEquals(sb2) - "+ result4);

        boolean result5 = str1.contentEquals(str2);  // works nice and returns true
        System.out.println(" str1.contentEquals(str2) - "+ result5);
    }
}

आउटपुट:

 str1.equals(str2) - true
 str1.equals(sb1) - false
 str1.contentEquals(sb1) - true
 str1.contentEquals(sb2) - false
 str1.contentEquals(str2) - true

— Asfab
स्रोत

7

स्ट्रिंग # बराबर वस्तु को तर्क के रूप में लेता है और जाँचता है कि यह स्ट्रिंग ऑब्जेक्ट का उदाहरण है या नहीं। यदि तर्क वस्तु स्ट्रिंग ऑब्जेक्ट है तो यह चरित्र चरित्र सामग्री की तुलना करता है। यह सच है कि दोनों स्ट्रिंग ऑब्जेक्ट्स की सामग्री एक ही है।

स्ट्रिंग # contentEquals एक तर्क के रूप में CharSequence इंटरफ़ेस लेता है। वर्णानुक्रम 2 तरीकों से लागू किया जा सकता है- i का उपयोग करके) स्ट्रिंग वर्ग या (ii) AbstractStringBuilder (स्ट्रिंगर का मूल वर्ग, StringBuilder)

में contentEquals () लंबाई किसी भी वस्तु उदाहरण जांच से पहले तुलना में है। यदि लंबाई समान है तो यह तर्क की जाँच करता है कि ऑब्जेक्ट AbstractStringBuilder का उदाहरण है या नहीं। यदि ऐसा है (यानी StringBuffer या StringBuilder) तो सामग्री चरित्र द्वारा जाँच की जाती है। यदि तर्क में स्ट्रिंग ऑब्जेक्ट का एक उदाहरण है, तो स्ट्रिंग # स्ट्रिंग # सामग्री से बुलाया बराबर है।

तो संक्षेप में,

स्ट्रिंग # समतुल्य सामग्री चरित्र की तुलना चरित्र के मामले में तर्क से करता है स्ट्रिंग वस्तु भी है। और स्ट्रिंग # contentEquals केस लॉजिक ऑब्जेक्ट में सामग्री की तुलना CharSequence इंटरफ़ेस लागू करता है।

स्ट्रिंग # contentEquals उस स्थिति में धीमी होती है जब हम दो समान लंबाई वाली स्ट्रिंग सामग्री की तुलना करते हैं जैसे स्ट्रिंग # contentEquals आंतरिक रूप से स्ट्रिंग # बराबर स्ट्रिंग ऑब्जेक्ट के लिए कॉल करता है।

मामले में हम अंतर सामग्री की लंबाई के साथ वस्तुओं की तुलना करने की कोशिश करते हैं ("abcd" के साथ "abc" कहते हैं) तो स्ट्रिंग # contentEquals स्ट्रिंग # बराबर की तुलना में तेज़ है। क्योंकि लंबाई की तुलना किसी भी वस्तु उदाहरण जाँच से पहले की जाती है।

— अनिर्बान पाल
स्रोत

6

contentEquals()विधि चेकों सामग्री एक के बीच एक ही कर रहे हैं String, StringBuffer, आदि जो चार अनुक्रम किसी तरह का।

— fastcodejava
स्रोत

5

BTW, अंतर का ऐतिहासिक कारण यह है कि स्ट्रिंग का मूल रूप से कोई सुपरक्लास नहीं था, इसलिए String.equals () स्ट्रिंग को अपने तर्क के रूप में लेता है। जब CharSequence को String के सुपरक्लास के रूप में पेश किया गया था, तो उसे अपने स्वयं के समानता परीक्षण की आवश्यकता थी, जो सभी CharSequence कार्यान्वयन में काम करता था, और जो String द्वारा समान (पहले से उपयोग में) से नहीं टकराएगा ... इसलिए CharSequence.contentEquals ( ), जो स्ट्रिंग द्वारा विरासत में मिला है।

यदि Java 1.0 में CharSequence मौजूद है, तो हम केवल CharSequence.equals () और String को ही लागू करेंगे।

आह, भाषाओं के विकास की खुशियाँ ...

— keshlam
स्रोत