तुलना () बनाम बराबर ()

Question

Stringजावा में समानता के लिए परीक्षण करते समय मैंने हमेशा इसका उपयोग किया है equals()क्योंकि मेरे लिए यह इसके लिए सबसे प्राकृतिक तरीका है। आखिरकार, इसका नाम पहले से ही कहता है कि यह क्या करने का इरादा है। हालाँकि, मेरे एक सहयोगी ने हाल ही में मुझे बताया कि मुझे compareTo() == 0इसके बजाय उपयोग करना सिखाया गया था equals()। यह अप्राकृतिक लगता है (जैसा compareTo()कि आदेश देने के लिए है और समानता के लिए तुलना नहीं) और यहां तक ​​कि कुछ हद तक खतरनाक है (क्योंकि compareTo() == 0जरूरी नहीं कि सभी मामलों में समानता हो, हालांकि मुझे पता है कि यह Stringमेरे लिए है)।

वह नहीं जानता था कि क्यों उसे के compareTo()बजाय का उपयोग करने के equals()लिए सिखाया गया था String, और मैं भी कोई कारण नहीं मिल सका। क्या यह वास्तव में व्यक्तिगत स्वाद की बात है, या विधि के लिए कोई वास्तविक कारण है?

Comments

माइक्रो-ऑप्टिमाइज़ेशन स्तर पर सख्ती से बोलना, जिसे हमें कभी भी समय से पहले नहीं बोलना चाहिए, .equalsIgnoreCase()अगर यह उचित है, तो सबसे तेज़ तुलना .equals()है।

यह एक पुराना सवाल है, लेकिन इसमें एक डला हुआ है जिसे मैं हाइलाइट करना चाहता था: " compareTo() == 0जरूरी नहीं कि सभी मामलों में समानता हो"। यह बिल्कुल सही है! यह वास्तव में जावा एपीआई विनिर्देशों में वाक्यांश "बराबरी के अनुरूप" का अर्थ है, उदाहरण के लिए तुलनीय वर्ग विनिर्देश में। उदाहरण के लिए, स्ट्रिंग की तुलना विधि बराबरी के साथ संगत है, लेकिन BigDecimal के तुलना विधि है असंगत बराबरी के साथ।

— स्टुअर्ट मार्क्स

Answer 1

एक अंतर यह है कि NullPointerException फेंकता है, "foo".equals((String)null)जबकि झूठे वापस आ जाता है "foo".compareTo((String)null) == 0। इसलिए वे स्ट्रिंग्स के लिए हमेशा विनिमेय नहीं होते हैं।

Comments

मुझे लगता है कि आपको इसका भी उल्लेख करना चाहिए। बराबर हैशकोड की गणना करता है। दो अलग-अलग तारों का हैशकोड, हालांकि दुर्लभ, एक ही हो सकता है। लेकिन जब ComparTo () का उपयोग करते हैं, तो यह चरित्र द्वारा स्ट्रिंग्स चरित्र की जांच करता है। तो इस मामले में दो तार सही वापस आएंगे यदि और केवल अगर उनकी वास्तविक सामग्री बराबर है।

— अश्विन

आपको क्यों लगता है कि बराबर हैशकोड की गणना करता है? आप देख सकते हैं कि यह मामला नहीं है: docjar.com/html/api/java/lang/String.java.html (पंक्ति 1013)।

— मोम

तुम सही हो। मैंने सोचा था कि बराबरी और हैशकोड एक-दूसरे के हाथ में हैं (बराबर की जाँच करता है कि दोनों के पास समान हैश कोड है)। फिर इन दोनों तरीकों को ओवरराइड करना क्यों आवश्यक है यदि आप उनमें से किसी एक को ओवरराइड करने का निर्णय लेते हैं।

— अश्विन

जब हम ओवरराइड करते हैं तो हैशकोड को ओवरराइड करना आवश्यक होता है क्योंकि अगर हैश

— मैप, हैशसेट और हैशटेबल

@ अश्विन यह आवश्यक है क्योंकि यदि असमानताएं वापस आती हैं, तो हैशकोड भी बराबर होना चाहिए। हालाँकि अगर हैशकोड समान हैं तो इसका मतलब यह नहीं है। असमान को वापस लौटना चाहिए

— एलन

Answer 2

2 मुख्य अंतर यह हैं कि:

1. equals किसी भी वस्तु को एक पैरामीटर के रूप में ले जाएगा, लेकिन compareTo ले जाएगा केवल स्ट्रिंग्स ले जाएगा।
2. equalsकेवल आपको बताता है कि वे समान हैं या नहीं, लेकिन compareToइस बात की जानकारी देता है कि स्ट्रिंग्स की तुलनात्मक रूप से कैसे की जाती है।

मैंने स्ट्रिंग वर्ग कोड पर एक नज़र डाली, और तुलना और समरूप के भीतर एल्गोरिथ्म मूल रूप से समान दिखता है। मेरा मानना ​​है कि उनकी राय सिर्फ स्वाद की बात थी, और मैं आपसे सहमत हूं - अगर आपको यह जानना जरूरी है कि स्ट्रिंग्स की समानता है और न कि जो पहले लेक्सोग्राफिक रूप से आती है, तो मैं उपयोग करूंगा equals।

Answer 3

समानता के लिए तुलना करते समय आपको उपयोग करना चाहिए equals() , क्योंकि यह आपके इरादे को स्पष्ट रूप से व्यक्त करता है।

compareTo() अतिरिक्त दोष यह है कि यह केवल उन वस्तुओं पर काम करता है जो लागू करते हैं Comparable इंटरफ़ेस को ।

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

Answer 4

compareToयदि स्ट्रिंग्स की लंबाई अलग-अलग है, तो अधिक काम करें। equalsकेवल गलत तरीके से वापस आ सकता है, जबकि compareToछँटाई क्रम को खोजने के लिए हमेशा पर्याप्त वर्णों की जांच करनी चाहिए।

Answer 5

compareTo()न केवल स्ट्रिंग्स पर लागू होता है, बल्कि किसी अन्य वस्तु पर भी लागू होता है क्योंकि compareTo<T>सामान्य तर्क लेता है T। स्ट्रिंग उन वर्गों में से एक है compareTo()जिन्होंने Comparableइंटरफ़ेस को लागू करके विधि को लागू किया है। (तुलना () तुलनीय इंटरफ़ेस के लिए एक विधि है)।तो कोई भी वर्ग तुलनात्मक इंटरफ़ेस को लागू करने के लिए स्वतंत्र है।

लेकिन compareTo()वस्तुओं का क्रम देता है , आमतौर पर वस्तुओं को आरोही या अवरोही क्रम में छांटने में उपयोग किया जाता है, जबकि equals()केवल समानता के बारे में बात करेंगे और कहेंगे कि वे समान हैं या नहीं।

Answer 6

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

तुलना (अपने सूचकांक में) दो वर्णों की तुलना करता है और उसी के अनुसार पूर्णांक (धनात्मक या ऋणात्मक) देता है।

String s1 = "ab";
String s2 = "ab";
String s3 = "qb";
s1.compareTo(s2); // is 0
s1.compareTo(s3); // is -16
s3.compareTo(s1); // is 16

Answer 7

बराबर () अधिक कुशल हो सकता है तो तुलना () ।

तुलना और समानता के बीच एक बहुत महत्वपूर्ण अंतर:

"myString".compareTo(null);  //Throws java.lang.NullPointerException
"myString".equals(null);     //Returns false

बराबरी () की जाँच करता है कि दो वस्तुएं समान हैं या नहीं और बूलियन वापस करती है।

से तुलना() (इंटरफ़ेस से) एक पूर्णांक देता है। यह जाँचता है कि दोनों में से कौन सी वस्तु "से कम" है, "दूसरे के बराबर" या "अधिक" है। सभी ऑब्जेक्ट्स को तार्किक रूप से ऑर्डर नहीं किया जा सकता है, इसलिए एक तुलना () विधि हमेशा समझ में नहीं आती है।

ध्यान दें कि बराबर () ऑब्जेक्ट्स के बीच ऑर्डर को परिभाषित नहीं करता है, जो तुलना () करता है।

अब मैं आपको यह निष्कर्ष निकालने के लिए दोनों विधियों के स्रोत कोड की समीक्षा करने की सलाह देता हूं कि तुलना के लिए यह बेहतर है कि कुछ गणित गणनाओं को शामिल किया जाए।

Answer 8

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

स्रोत: http://java.sun.com/javase/6/docs/api/java/lang/String.html

Answer 9

equals() ओपी के मामले में पसंद का तरीका होना चाहिए।

के कार्यान्वयन को देखते हुए equals()और compareTo()में java.lang.String grepcode पर , हम आसानी से देख सकते हैं कि बराबरी बेहतर है अगर हम सिर्फ दो स्ट्रिंग्स की समानता को लेकर चिंतित हैं:

equals():

1012   सार्वजनिक  बूलियन बराबर ( वस्तु anObject) { 
1013       अगर ( इस == anObject) { 
1014           वापसी  सच ; 
1015       } 
1016       अगर (anObject instanceof  स्ट्रिंग ) { 
1017           स्ट्रिंग anotherString = ( स्ट्रिंग ) anObject; 
1018           int n = count; 
1019           अगर (n == एक और स्ट्रिंग .ाउंट) { 
1020               चार v1 [] = मूल्य; 
1021               चार v2 [] = otherString.value; 
1022               इंटi = ऑफसेट; 
1023               int j = otherString.offset; 
1024               जबकि (n--! = 0) { 
1025                   if (v1 [i ++]! = V2 [j ++]) 
1026                       वापस  झूठे ; 
1027               } 
1028               वापसी  सही ; 
1029           } 
1030       } 
1031       झूठे वापस  ; 1032   }

और compareTo():

1174   सार्वजनिक  int तुलना (किसी अन्य स्ट्रिंग ) { 
1175       int len1 = count; 
1176       int len2 = otherString.count; 
1177       int n = गणित। min (len1, len2); 
1178       char v1 [] = मूल्य; 
1179       चार वी 2 [] = otherString.value; 
1180       int i = ऑफसेट; 
1181       int j = otherString.offset; 
1183       अगर (i == j) { 
1184           int k = i; 
1185           int lim = n + i; 
1186           जबकि  (k <lim) {
1187               चार c1 = v1 [k]; 
1188               char c2 = v2 [k];
1189               अगर (c1! = C2) { 
1190                   रिटर्न c1 - c2; 
1191               } 
1192               k ++; 
1193           } 
1194       } और { 
1195           जबकि (n--! = 0) { 
1196               चार c1 = v1 [i ++]; 
1197               चार सी 2 = वी 2 [जे ++]; 
1198               अगर (c1! = C2) { 
1199                   रिटर्न c1 - c2; 
1200               } 
1201           } 
1202       }
 1203       वापसीlen1 - len2; 
1204   }

जब एक तार दूसरे का एक उपसर्ग होता है, तो इसका प्रदर्शन और compareTo()भी बुरा होता है क्योंकि इसे अभी भी लेक्सिकोग्राफिक ऑर्डर निर्धारित करने की आवश्यकता होती है, जबकि equals()किसी भी अधिक चिंता नहीं होगी और तुरंत गलत वापस आ जाएगी।

मेरी राय में, हमें इन दोनों का उपयोग करना चाहिए जैसा कि उनका इरादा था:

• equals() समानता के लिए जाँच करने के लिए, और
• compareTo() शाब्दिक आदेश खोजने के लिए।

Answer 10

बराबर () की जाँच करता है कि दो तार बराबर हैं या नहीं। यह बूलियन मान देता है। तुलना () यह जांचता है कि क्या स्ट्रिंग ऑब्जेक्ट के बराबर है, अन्य स्ट्रिंग ऑब्जेक्ट के लिए अधिक या छोटा है। यह परिणाम देता है: 1 यदि स्ट्रिंग ऑब्जेक्ट 0 से अधिक है, यदि दोनों बराबर -1 हैं यदि स्ट्रिंग अन्य स्ट्रिंग की तुलना में छोटा है

eq:

String a = "Amit";
String b = "Sumit";
String c = new String("Amit");
System.out.println(a.equals(c));//true
System.out.println(a.compareTo(c)); //0
System.out.println(a.compareTo(b)); //1

Answer 11

कुछ चीजें हैं जिन्हें आपको जावा में तुलना करते समय ध्यान में रखने की आवश्यकता है जैसे जावा में तुलना करना बराबर होना चाहिए और पूर्णांक फ़ील्ड की तुलना के लिए घटाव का उपयोग नहीं किया जाना चाहिए क्योंकि वे अतिप्रवाह कर सकते हैं। विवरण के लिए जावा में तुलनित्र को ओवरराइड करते समय याद रखने योग्य बातें जांचें ।

Answer 12

यह नेक्रोमेंसी में एक प्रयोग है :-)

अधिकांश उत्तर प्रदर्शन और एपीआई अंतर की तुलना करते हैं। वे मौलिक बिंदु को याद करते हैं कि दो कार्यों में बस अलग-अलग शब्दार्थ हैं।

आपका अंतर्ज्ञान सही है। x.equals (y) x.compareTo (y) == के साथ विनिमेय नहीं है। 0. पहली पहचान की तुलना करता है, जबकि दूसरा 'आकार' की धारणा की तुलना करता है। यह सच है कि कई मामलों में, विशेष रूप से आदिम प्रकारों के साथ, ये दो सह-संरेखित हैं।

सामान्य मामला यह है:

यदि x और y समान हैं, तो वे समान 'आकार' साझा करते हैं: यदि x.equals (y) सत्य है => x.compareTo (y) 0 है।

हालांकि, यदि x और y समान आकार साझा करते हैं, तो इसका मतलब यह नहीं है कि वे समान हैं।

अगर x.compareTo (y) 0 है तो जरूरी नहीं कि x.equals (y) सही हो।

एक सम्मोहक उदाहरण जहां पहचान आकार से भिन्न होती है वह जटिल संख्या होगी। मान लें कि तुलना उनके पूर्ण मूल्य द्वारा की जाती है। तो दिए गए दो जटिल नंबर: Z1 = a1 + b1 * i और Z2 = a2 + b2 * i:

Z1.equals (z2) सही है और यदि केवल a1 = a2 और b1 = b2 है तो।

जब तक वे (a1, b1) और (a2, b2) जोड़े के लिए Z1.compareTo (Z2) जोड़े जाते हैं, जब तक वे a1 ^ 2 + b1 ^ 2 == a2 a2 + b2 ^ 2 को संतुष्ट करते हैं।

Comments

x.equals (y) का अर्थ पहचान नहीं है, इसका मतलब समानता है। जावा में उपयोगकर्ता-परिभाषित प्रकारों के लिए x == y का उपयोग करके पहचान की तुलना की जाती है।

— फर्नांडो पेलिसियोनी

Answer 13

बराबरी अधिक कुशल हो सकती है फिर तुलना।

यदि स्ट्रिंग में वर्ण अनुक्रम की लंबाई मेल नहीं खाती है तो स्ट्रिंग्स समान नहीं हैं, इसलिए अस्वीकृति बहुत तेज हो सकती है।

इसके अलावा अगर यह एक ही वस्तु (पहचान समानता बल्कि तार्किक समानता) है, तो यह अधिक कुशल भी होगी।

यदि उन्होंने हैशकोड कैशिंग भी लागू किया है तो उनके हैशकोड के मैच न होने की स्थिति में गैर-बराबरी को अस्वीकार करना और भी तेज़ हो सकता है।

Answer 14

String.equals()आवश्यकता नहीं है, instanceofजबकि ऑपरेटर की compareTo()आवश्यकता होती है। मेरे सहयोगी ने विधि instanceofमें कॉल की अत्यधिक संख्या के कारण बड़े प्रदर्शन को गिरा दिया है equals(), हालांकि मेरा परीक्षण compareTo()केवल थोड़ा तेज साबित हुआ है।

मैं, हालांकि, जावा 1.6 का उपयोग कर रहा था। अन्य संस्करणों (या अन्य JDK विक्रेताओं) पर अंतर बड़ा हो सकता है।

परीक्षण 1000 तत्व सरणियों में प्रत्येक-से-प्रत्येक स्ट्रिंग की तुलना में 10 बार दोहराया गया।

Comments

मुझे लगता है कि आपने बहुत ही छोटे तार का इस्तेमाल किया होगा, सभी एक ही लंबाई और उच्च विविधता के साथ पहले चरित्र में एक परिणाम प्राप्त करने के लिए जहां compareTo()तेजी से है equals()? लेकिन वास्तविक दुनिया के डेटा के अधिकांश सेटों की equals()तुलना में बहुत तेज है compareTo() == 0। equals()चमकता है अगर तार में एक सामान्य उपसर्ग है लेकिन अलग-अलग लंबाई है या यदि वे वास्तव में एक ही वस्तु हैं।

— x4u

खैर, मेरा परीक्षण हाइपोटिस के खिलाफ था कि उदाहरण के लिए प्रदर्शन हत्यारा है, इसलिए तार वास्तव में कम थे।

— डेन्यूबियन नाविक

यदि आपकी स्ट्रिंग यादृच्छिक है और अधिकतर लंबाई में भिन्न है, तो अधिक स्पष्ट विकल्प की तुलना में बराबर () विधि होनी चाहिए (क्योंकि अधिकांश मामलों में यह तुरंत झूठे वापस आ जाएगा यदि वे लंबाई में बराबर नहीं हैं।

— संवत

Answer 15

1. equalsकिसी भी वस्तु को एक पैरामीटर के रूप में ले सकते हैं लेकिन compareToकेवल स्ट्रिंग ले सकते हैं।

2. जब कॉम्बो नल, compareToएक अपवाद फेंक देगा

3. जब आप जानना चाहते हैं कि अंतर कहां है, तो आप उपयोग कर सकते हैं compareTo।

Comments

तुलना किसी भी वस्तु को तर्क के रूप में ले सकती है। जैसा कि @ अपूर्वा जाधव ने ऊपर कहा, तुलनीय एक सामान्य तर्क लेता है। यदि आप तुलनात्मक <स्ट्रिंग> के रूप में comaparable को लागू करते हैं, तो आपको केवल स्ट्रिंग्स का उपयोग करने की अनुमति है।

— गौरव कुमार

Answer 16

• equals: समानता की जाँच और डुप्लिकेट को प्रतिबंधित करने के लिए आवश्यक। यदि वे डुप्लिकेट ढूंढना चाहते थे तो जावा लाइब्रेरी की कई कक्षाएं इसका उपयोग करती हैं। उदाहरण के HashSet.add(ob1)लिए केवल जोड़ देगा यदि वह मौजूद नहीं है। तो अगर आप कुछ वर्गों को इस तरह से बढ़ा रहे हैं तो ओवरराइड करें equals()।

• compareTo: तत्व के आदेश के लिए आवश्यक है। फिर से स्थिर छंटाई के लिए आपको समानता की आवश्यकता होती है, इसलिए एक वापसी 0 है।

Answer 17

बराबर -

1- हैश टेबल में सही प्रकार से काम करने की अनुमति देने के लिए गेटहैशकोड विधि को ओवरराइड करें।

2- एक समान विधि के कार्यान्वयन में एक अपवाद न फेंकें। इसके बजाय, एक अशक्त तर्क के लिए झूठी वापसी करें।

3-

  x.Equals(x) returns true.

  x.Equals(y) returns the same value as y.Equals(x).

  (x.Equals(y) && y.Equals(z)) returns true if and only if x.Equals(z) returns true.

X.Equals (y) के क्रमिक चालान तब तक वापस आते हैं जब तक x और y द्वारा संदर्भित ऑब्जेक्ट संशोधित नहीं होते हैं।

x.Equals(null) returns false.

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

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

   Object obj1 = new Object();
   Object obj2 = new Object();
   Console.WriteLine(obj1.Equals(obj2));
   obj1 = obj2; 
   Console.WriteLine(obj1.Equals(obj2)); 

आउटपुट: -

False
True

जबकि तुलना -

एक ही प्रकार की दूसरी वस्तु के साथ वर्तमान आवृत्ति की तुलना करता है और एक पूर्णांक देता है जो इंगित करता है कि क्या वर्तमान उदाहरण अन्य वस्तु के समान क्रम में उसी स्थिति में है, का अनुसरण करता है, या होता है।

यह लौटाता है -

शून्य से कम - यह उदाहरण सॉर्ट क्रम में पूर्ववर्ती है। शून्य - यह उदाहरण ओज के समान क्रम में उसी स्थिति में होता है। शून्य से अधिक - यह उदाहरण क्रम में obj का अनुसरण करता है।

यह ArgumentException को फेंक सकता है यदि ऑब्जेक्ट उदाहरण के समान नहीं है।

उदाहरण के लिए आप यहां जा सकते हैं।

इसलिए मैं तुलना करने के स्थान पर समान का उपयोग करने के लिए बेहतर सुझाव देता हूं।

Comments

कोई GetHashCode()विधि नहीं है। क्या आपका मतलब है hashCode()?

— लोर्न

Answer 18

"बराबर" वस्तुओं की तुलना करते हैं और सच्चे या झूठे की तुलना करते हैं और "वापसी 0 की तुलना करें यदि यह सच है या एक संख्या [> 0] या [<0] अगर यहां झूठी है तो एक उदाहरण:

<!-- language: lang-java -->
//Objects Integer
Integer num1 = 1;
Integer num2 = 1;
//equal
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));
//New Value
num2 = 3;//set value
//diferent
System.out.println(num1.equals(num2));
System.out.println(num1.compareTo(num2));

परिणाम:

num1.equals(num2) =true
num1.compareTo(num2) =0
num1.equals(num2) =false
num1.compareTo(num2) =-1

प्रलेखन की तुलना करें: https://docs.oracle.com/javase/7/docs/api/java/lang/Comparity.html

दस्तावेज़ीकरण के बराबर: https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)

Answer 19

यहाँ एक बात का उपयोग करते समय महत्वपूर्ण है compareTo()से अधिक equals()है कि compareToकक्षाओं के लिए काम करता है कि औजार 'तुलनीय' इंटरफेस अन्यथा यह एक फेंक देते हैं NullPointerException। Stringकक्षाएं लागू होती हैं तुलनात्मक इंटरफ़ेस जबकि StringBufferआप ऑब्जेक्ट में नहीं बल्कि ऑब्जेक्ट "foo".compareTo("doo")में उपयोग कर सकते हैं ।StringStringBuffer

Answer 20

String s1 = "a";
String s2 = "c";

System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

यह प्रिंट -2 और असत्य है

String s1 = "c";
String s2 = "a";
System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

यह प्रिंट 2 और असत्य है

String s1 = "c";
String s2 = "c";
System.out.println(s1.compareTo(s2));
System.out.println(s1.equals(s2));

यह 0 और सच को प्रिंट करता है

बराबरी रिटर्न बूलियन अगर और केवल अगर दोनों तार मेल खाते हैं।

तुलना करने का मतलब केवल यह बताना नहीं है कि वे मेल खाते हैं बल्कि यह भी बताने के लिए कि कौन सा स्ट्रिंग दूसरे की तुलना में कम है, और यह भी कि कितना, लेक्सोग्राफिक रूप से। यह ज्यादातर संग्रह में छांटते समय उपयोग किया जाता है।

Answer 21

मैं मानता हूं equalsऔर वापसी के equalsIgnoreCaseतरीके और जो उपयोगी है यदि आप स्ट्रिंग ऑब्जेक्ट के मूल्यों की तुलना करना चाहते थे, लेकिन लागू करने और विधियों के मामले में सकारात्मक, नकारात्मक और शून्य मान लौटाता है जो छँटाई के मामले में उपयोगी होगा।StringtruefalsecompareTocompareToIgnoreCase