जावा चैलेंजर्स # 2: स्ट्रिंग तुलना

हमेशा की तरह, हमारे पास पाठ्यक्रम की शुरुआत के लिए बहुत देर हो चुकी है, इसलिए कल ही नए धागे "जावा डेवलपर" के बीच एक दूसरा पाठ आयोजित किया गया। लेकिन यह ऐसा है, जीवन में छोटी चीजें, लेकिन अब तक हम जावा चैलेंजर्स लेखों की एक श्रृंखला प्रकाशित करना जारी रखते हैं, जिसका अनुवाद आपके लिए तैयार किया गया है।

जावा में, String वर्ग एक char सरणी ( अनुवादक का नोट - जावा 9 के साथ पहले से ही एक byte सरणी है, जावा 9 में कॉम्पैक्ट स्ट्रिंग्स देखें ) को एन्क्रिप्ट करता है । सरल शब्दों में, String एक ऐसा वर्ण है जिसका उपयोग शब्दों, वाक्यों या अन्य रचनाओं को लिखने के लिए किया जाता है।

एनकैप्सुलेशन ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में सबसे शक्तिशाली अवधारणाओं में से एक है। इनकैप्सुलेशन के लिए धन्यवाद, आपको यह जानने की आवश्यकता नहीं है कि String वर्ग कैसे काम करता है। आपको केवल इसके इंटरफ़ेस के तरीकों को जानना होगा।

जब आप जावा में String वर्ग को देखते हैं, तो आप देख सकते हैं कि कैसे char को संक्षिप्त किया गया है:

 public String(char value[]) { this(value, 0, value.length, null); } 

एन्कैप्सुलेशन को बेहतर ढंग से समझने के लिए, एक भौतिक वस्तु की कल्पना करें: एक मशीन। क्या आपको यह जानने की ज़रूरत है कि एक कार हुड के तहत कैसे काम करती है ताकि इसे ड्राइव किया जा सके? बेशक, लेकिन आपको पता होना चाहिए कि कार के इंटरफेस क्या करते हैं: गैस पेडल, ब्रेक और स्टीयरिंग व्हील। इनमें से प्रत्येक इंटरफेस कुछ कार्यों का समर्थन करता है: त्वरण, ब्रेक लगाना, बाएं मुड़ना, दाएं मुड़ना। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में भी यही सच है।

जावा चैलेंजर्स श्रृंखला में पहला लेख विधि अधिभार के बारे में था, जिसका उपयोग व्यापक रूप से String वर्ग में किया जाता है। ओवरलोडिंग आपकी कक्षाओं को वास्तव में लचीला बना सकती है:

 public String(String original) {} public String(char value[], int offset, int count) {} public String(int[] codePoints, int offset, int count) {} public String(byte bytes[], int offset, int length, String charsetName) {} //    ... 

String क्लास कैसे काम करता है, यह समझने की कोशिश करने के बजाय, यह लेख आपको यह समझने में मदद करेगा कि यह क्या करता है और इसे अपने कोड में कैसे उपयोग करें।

एक स्ट्रिंग पूल क्या है?

String वर्ग यकीनन जावा में सबसे अधिक इस्तेमाल किया जाने वाला वर्ग है। यदि हम हर बार जब हम String उपयोग करते हैं तो गतिशील मेमोरी (मेमोरी हीप) में एक नई वस्तु बनाते हैं, तो हम बहुत सारी मेमोरी बर्बाद कर देंगे। स्ट्रिंग पूल प्रत्येक पंक्ति मान के लिए केवल एक ऑब्जेक्ट संग्रहीत करके इस समस्या को हल करता है।

एक पंक्ति पूल में लाइनें

यद्यपि हमने Duke और Juggy के मूल्यों के साथ कई String चर बनाए, केवल दो ऑब्जेक्ट्स बनाए गए हैं और डायनेमिक मेमोरी (ढेर) में संग्रहीत हैं। प्रमाण के लिए निम्न कोड उदाहरण देखें। (याद रखें कि जावा में, " == " ऑपरेटर का उपयोग दो वस्तुओं की तुलना करने और यह निर्धारित करने के लिए किया जाता है कि एक ही वस्तु समान है या नहीं।)

 String juggy = "Juggy"; String anotherJuggy = "Juggy"; System.out.println(juggy == anotherJuggy); 

यह कोड true वापस आएगा क्योंकि String में दो String वैरिएबल एक ही ऑब्जेक्ट को इंगित करते हैं। उनके अर्थ समान हैं।

अपवाद new ऑपरेटर है।

अब इस कोड को देखें - यह पिछले उदाहरण के समान दिखता है, लेकिन एक अंतर है।

 String duke = new String("duke"); String anotherDuke = new String("duke"); System.out.println(duke == anotherDuke); 

पिछले उदाहरण के आधार पर, आप सोच सकते हैं कि यह कोड true लौटेगा, लेकिन ऐसा नहीं है। new ऑपरेटर को जोड़ने से मेमोरी में एक नया String ऑब्जेक्ट बन जाता है। इस प्रकार, जेवीएम दो अलग-अलग वस्तुओं का निर्माण करेगा।

देशी तरीके

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

स्ट्रिंग पूल और intern() विधि

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

यहाँ जावदोक ने हमें intern() पद्धति के बारे में बताया है:

  /** *      . * *   ( )   {@code String}. * *    intern,     , *    {@code String},   *  {@link #equals(Object)},     . * ,   {@code String}   *        {@code String}. * *   ,      {@code s}  {@code t}, * {@code s.intern() == t.intern()}  {@code true} *    ,  {@code s.equals(t)}  {@code true}. * *       . *      3.10.5 The Java™ Language Specification. * * @returns ,         , * , ,       . * * @jls 3.10.5 String Literals */ public native String intern(); 

स्ट्रिंग पूल में तारों को संग्रहीत करने के लिए intern() विधि का उपयोग किया जाता है। सबसे पहले, यह देखने के लिए जांचता है कि क्या पूल में पहले से मौजूद एक पंक्ति मौजूद है या नहीं। यदि नहीं, तो यह पूल में एक नई पंक्ति बनाता है। रो पूल तर्क फ्लाईवेट पैटर्न पर आधारित है।

अब, ध्यान दें कि जब हम दो लाइन बनाने के लिए new का उपयोग करते हैं,

 String duke = new String("duke"); String duke2 = new String("duke"); System.out.println(duke == duke2); //    false System.out.println(duke.intern() == duke2.intern()); //    true 

new कीवर्ड के साथ पिछले उदाहरण के विपरीत, इस मामले में तुलना true होगी। ऐसा इसलिए है क्योंकि intern() पद्धति का उपयोग यह सुनिश्चित करता है कि स्ट्रिंग पूल में है।

String कक्षा में equals पद्धति

equals() विधि का उपयोग यह जांचने के लिए किया जाता है कि दो वर्ग समान हैं या नहीं। चूंकि equals() Object क्लास में स्थित है, प्रत्येक जावा क्लास को यह विरासत में मिला है। लेकिन इसके सही तरीके से काम करने के लिए equals() पद्धति को ओवरराइड किया जाना चाहिए। बेशक, String ओवरराइड्स के equals() ।

एक बार देख लो:

 public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String aString = (String)anObject; if (coder() == aString.coder()) { return isLatin1() ? StringLatin1.equals(value, aString.value) : StringUTF16.equals(value, aString.value); } } return false; } 

जैसा कि आप देख सकते हैं, String वर्ग के मूल्य की तुलना equals() माध्यम से की जाती equals() , न कि किसी वस्तु संदर्भ के माध्यम से। इससे कोई फर्क नहीं पड़ता कि वस्तुओं के संदर्भ अलग हैं; परिस्थितियों की तुलना की जाएगी।

सामान्य String तरीके

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

String वर्ग के सबसे सामान्य तरीकों पर विचार करें:

 //         trim() //     substring(int beginIndex, int endIndex) //    length() //  ,     replaceAll(String regex, String replacement) // ,     CharSequence   contains(CharSequences) 

स्ट्रिंग तुलना समस्या का समाधान करें

आइए देखें कि आपने एक छोटी सी पहेली को हल करके String कक्षा के बारे में क्या सीखा।

इस कार्य में, आपने जिन अवधारणाओं को सीखा है, उनका उपयोग करके कई पंक्तियों की तुलना करते हैं। नीचे दिए गए कोड को देखते हुए, क्या आप प्रत्येक चर result का मूल्य निर्धारित कर सकते हैं?

 public class ComparisonStringChallenge { public static void main(String... doYourBest) { String result = ""; result += " powerfulCode ".trim() == "powerfulCode" ? "0" : "1"; result += "flexibleCode" == "flexibleCode" ? "2" : "3"; result += new String("doYourBest") == new String("doYourBest") ? "4" : "5"; result += new String("noBugsProject") .equals("noBugsProject") ? "6" : "7"; result += new String("breakYourLimits").intern() == new String("breakYourLimits").intern() ? "8" : "9"; System.out.println(result); } } 

निष्कर्ष क्या होगा?

• A: 02468
• B: 12469
• C: 12579
• डी: 12568

लेख के अंत में सही उत्तर दिया गया है।

अब क्या हुआ? String व्यवहार को समझना

पहली पंक्ति में हम देखते हैं:

 result += " powerfulCode ".trim() == "powerfulCode" ? "0" : "1"; 

इस स्थिति में, परिणाम false , क्योंकि जब trim() विधि रिक्त स्थान को हटा देती है, तो यह new ऑपरेटर का उपयोग करके एक नया String बनाता है।

आगे हम देखते हैं:

 result += "flexibleCode" == "flexibleCode" ? "2" : "3"; 

यहां कोई रहस्य नहीं है; पंक्तियाँ पंक्ति पूल में समान हैं। यह तुलना true ।

फिर, हमारे पास है:

 result += new String("doYourBest") == new String("doYourBest") ? "4" : "5"; 

दो नई लाइनों के निर्माण के लिए new लीड का उपयोग करना और इससे कोई फर्क नहीं पड़ता कि उनके मूल्य समान हैं या नहीं। इस मामले में, यदि मूल्य समान हैं, तो भी तुलना false होगी।

अगला:

 result += new String("noBugsProject") .equals("noBugsProject") ? "6" : "7"; 

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

इस मामले में, इससे कोई फर्क नहीं पड़ता कि विभिन्न वस्तुओं या नहीं, क्योंकि मूल्य की तुलना की जाती है। नतीजा true ।

अंत में, हमारे पास है:

 result += new String("breakYourLimits").intern() == new String("breakYourLimits").intern() ? "8" : "9"; 

जैसा कि आपने पहले देखा, intern() विधि एक स्ट्रिंग पूल में एक स्ट्रिंग डालती है। दोनों लाइनें एक ही वस्तु की ओर इशारा करती हैं, इसलिए इस मामले में true ।

आम स्ट्रिंग त्रुटियाँ

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

ऑब्जेक्ट संदर्भों की तुलना करने के लिए String विधियों का उपयोग करना भी मुश्किल हो सकता है। ख़ासियत यह है कि यदि विधि लाइन में कुछ बदलती है, तो वस्तुओं के लिए अलग-अलग संदर्भ होंगे।

स्पष्ट करने में मदद करने के लिए कुछ उदाहरण:

 System.out.println("duke".trim() == "duke".trim()); 

यह तुलना सही होगी क्योंकि trim() विधि एक नई रेखा नहीं बनाती है।

 System.out.println(" duke".trim() == "duke".trim()); 

इस मामले में, पहली trim() विधि एक नई लाइन उत्पन्न करती है, क्योंकि विधि अपना काम करेगी और इसलिए लिंक अलग-अलग होंगे।

अंत में, जब trim() अपना काम करता है, तो यह एक नई लाइन बनाता है:

 //   trim   String new String(Arrays.copyOfRange(val, index, index + len), LATIN1); 

तार के बारे में क्या याद रखना

• पंक्तियों को आपस में जोड़ा नहीं जा सकता है, इसलिए पंक्ति अवस्था को बदला नहीं जा सकता।

  
  

• मेमोरी को बचाने के लिए, JVM स्ट्रिंग पूल में स्टोर करता है। एक नई लाइन बनाते समय, JVM किसी मौजूदा ऑब्जेक्ट पर अपनी वैल्यू और पॉइंट्स चेक करता है। यदि पूल में इस मान के साथ एक पंक्ति नहीं है, तो JVM एक नई पंक्ति बनाता है।

  
  

• ऑपरेटर " == " वस्तु संदर्भों की तुलना करता है। equals() विधि स्ट्रिंग मानों की तुलना करती है। सभी वस्तुओं पर एक ही नियम लागू होगा।

  
  

• new ऑपरेटर का उपयोग करते समय, ढेर में एक नई लाइन बनाई जाएगी (अनुवादक का नोट - यह मूल में लिखा गया है कि यह पूल में है, लेकिन यह नहीं है, धन्यवाद zagayevskiy ), भले ही एक ही मूल्य के साथ एक रेखा हो।

  
  

जवाब है

इस समस्या का उत्तर डी है। निष्कर्ष 12568 होगा।

जारी रखने के लिए ...