हाय हब्र!

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

एक जावा डेवलपर को अक्सर विभिन्न डेटा संरचनाओं से निपटना पड़ता है। यह एरेज़, मानचित्र के सभी प्रकार के संग्रह या कार्यान्वयन हो सकते हैं। ऐसा लगता है कि उनके साथ सब कुछ स्पष्ट और समझ में आता है, लेकिन कई छोटी चीजें हैं जो आसानी से ठोकर खा सकती हैं।

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


^{Unsplash पर ammiel jr द्वारा फोटो}

कैट

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

सरणी-आधारित संग्रह प्राप्त करने का सबसे अच्छा तरीका क्या है?

मैं एक सरणी के आधार पर एक संग्रह के गठन के साथ शुरू करने का सुझाव देता हूं।

सबसे अधिक बार, यह विधि होती है:

Integer[] someArray = {9, 10, 11, 12}; List<Integer> list = Arrays.asList(someArray); 

यह निश्चित रूप से काम करता है, लेकिन इसके साथ सब कुछ ठीक है? और क्या कोई वैकल्पिक उपाय हैं?

इस दृष्टिकोण के दो मंत्र एक साथ दिमाग में आते हैं:

• सबसे पहले, Arrays.asList विधि एक सूची देता है। लेकिन क्या होगा अगर हमें संग्रह के एक और कार्यान्वयन की आवश्यकता है ? Arrays.asList इसे अनुमति नहीं देगा, लेकिन एक विकल्प को थोड़ा आगे माना जाएगा।
• दूसरे, Arrays.asList को कॉल करके प्राप्त की गई सूची आकार बदलने का समर्थन नहीं करती है। मुझे लगता है कि इस तरह की सूची के साथ काम करने से कई अपवाद उत्पन्न हुए हैं।

संग्रह इंटरफ़ेस पर, आप Arrays.asList पद्धति का एक विकल्प पा सकते हैं - Collections.addAll विधि। इसका उपयोग कैसे करें:

 //      (List, Set, ...) Collection<Integer> collection = ...; Integer[] someArray = {9, 10, 8, 7}; Collections.addAll(collection, someArray); 

या बस:

 Collections.addAll(collection, 11, 12, 13, 14); 

Collections.addAll विधि इनपुट पर एक संग्रह ऑब्जेक्ट और एक सरणी को स्वीकार करती है। एक सरणी के बजाय, आप अल्पविराम द्वारा अलग किए गए तत्वों को भी निर्दिष्ट कर सकते हैं।

Arrays.asList पर Collections.addAll के क्या लाभ हैं?

• कलेक्शन.डैड एरे सरणी पर आधारित कलेक्शन बनाते समय शुरू करने के लिए, यह Arrays.asList के इनपुट के साथ कलेक्शन के ऐडऑल विधि की तुलना में बहुत तेजी से काम करता है। यह इस तरीके के JavaDoc में पाया जा सकता है:
  

  इस सुविधा पद्धति का व्यवहार c.addAll (Arrays.asList (एलिमेंट्स)) के समान है, लेकिन यह विधि अधिकांश के तहत काफी तेज चलने की संभावना है

• इसके अलावा, Collections.addAll न केवल सूची के साथ, बल्कि किसी भी अन्य संग्रह के साथ काम करता है।
• और इस विधि का उपयोग करते समय, आकार बदलने की कोई समस्या नहीं है।

किसी सरणी, बहुआयामी सरणी, या संग्रह को प्रिंट करने का सबसे आसान तरीका क्या है?

चलो एक सरणी और संग्रह का मुद्रित प्रतिनिधित्व प्राप्त करने के मुद्दे पर आगे बढ़ते हैं।

अगर हम सिर्फ System.out.println (someArray) बनाते हैं, तो हमें कुछ ऐसा मिलता है:
[Ljava.lang.Integer; @ 6d06d69c
एक समान परिणाम एक सरणी पर toString () पद्धति का उपयोग करते समय अपेक्षित है।
सरणी को आउटपुट करने के लिए, Arrays.toString (...) विधि बचाव में आती है।

 Integer[] someArray = new Integer[]{1, 2, 3}; System.out.println(Arrays.toString(someArray)); 

इस लाइन के लिए आउटपुट होगा:

 [१, २, ३] 

अगर हम एक बहुआयामी सरणी के बारे में बात कर रहे हैं, तो आप विधि का उपयोग कर सकते हैं: Arrays.deeptoString ।

 int[][] a = { {1, 2, 3}, {4, 5, 6} }; System.out.println(Arrays.deepToString(a)); 

इस स्निपेट का उत्पादन होगा:

  [[१, २, ३], [४, ५, ६]] 

इस प्रकार, अपने तत्वों को प्रदर्शित करने के लिए किसी भी लूप के माध्यम से सरणी को सॉर्ट करना आवश्यक नहीं है; यह इस पद्धति का उपयोग करने के लिए पर्याप्त है।

मानचित्र के संग्रह या कार्यान्वयन के लिए, कोई समस्या नहीं है। सरणी को छोड़कर सभी डेटा संरचनाएं सामान्य रूप से आउटपुट हैं।

मान लीजिए कि एक उदाहरण है:

 Collection<Integer> someCollection = new HashSet<>(); someCollection.add(1); someCollection.add(2); System.out.println(someCollection); Map<Integer, String> someMap = new HashMap<>(); someMap.put(1, "Some 1"); someMap.put(2, "Some 2"); System.out.println(someMap); 

नीचे दिए गए आउटपुट में ध्यान दें कि सेट और मैप दोनों को पढ़ने में आसान प्रारूप में प्रदर्शित किया गया था:

 [१, २] 
 {1 = कुछ 1, 2 = कुछ 2} 

एक दूसरे के साथ सरणियों की तुलना करना कितना आसान है?

ऐसी स्थितियां हैं जब आपको सरणियों की तुलना करने की आवश्यकता होती है। एरेस वर्ग में एक विधि है जो इस तरह की तुलना की अनुमति देती है। Arrays.equals विधि तत्वों की संख्या की तुलना करती है और संबंधित तत्वों की समानता की जांच करती है।

मान लें कि हमारे पास एक तत्व वर्ग है जिसमें एक क्षेत्र और कुछ समान हैं

 private class Element { final String name; private Element(String name) { this.name = name; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Element element = (Element) o; return Objects.equals(name, element.name); } @Override public int hashCode() { return Objects.hash(name); } } 

तीन सरणियों को परिभाषित करें:

 Element[] firstElementArray = { new Element("a"), new Element("b"), new Element("c") }; Element[] secondElementArray = {new Element("c"), new Element("b"), new Element("a") }; Element[] thirdElementArray = { new Element("a"), new Element("b"), new Element("c") }; 

ध्यान दें कि पहले और तीसरे सरणियों में एक ही क्रम में तत्व हैं।
अब आप Arrays.equals पद्धति का उपयोग करके तुलना कर सकते हैं।

 System.out.println("first equals to second? " + Arrays.equals(firstElementArray, secondElementArray)); System.out.println("second equals to third? " + Arrays.equals(secondElementArray, thirdElementArray)); System.out.println("first equals to third? " + Arrays.equals(firstElementArray, thirdElementArray)); 

परिणाम इस प्रकार होगा:

 पहले दूसरे के बराबर है?  झूठा 
 तीसरे के बराबर दूसरी?  झूठा 
 पहले तीसरे के बराबर है?  सच 

किसी सरणी की कुशलता से नकल कैसे करें?

अक्सर आप कोड में मैन्युअल रूप से लूप का उपयोग करके सरणियों की प्रतिलिपि देख सकते हैं। हालाँकि, एक System.arraycopy विधि है जो बहुत तेज़ी से कॉपी होगी।

मैं इस तरह के एक सरल उदाहरण को देखने का सुझाव देता हूं:

 Element[] elements = { new Element("a"), new Element("b"), new Element("c") }; Element[] copyOfElements = new Element[elements.length]; System.arraycopy(elements, 0, copyOfElements, 0, elements.length); System.out.println(Arrays.toString(copyOfElements)); 

हमारे पास तत्वों की एक सरणी है। हम समान लंबाई का एक खाली सरणी बनाते हैं और पहले से दूसरे तक सभी तत्वों को कॉपी करते हैं। परिणामस्वरूप, हम निम्नलिखित निष्कर्ष प्राप्त करते हैं:

 [तत्व {नाम = 'ए ’}, तत्व {नाम =} बी’}, तत्व {नाम =' सी ’}] 

किसी सरणी या संग्रह को विभिन्न तरीकों से कैसे सॉर्ट करें?

Arrays.sort (someArray) विधि का उपयोग करके एरर्स को सॉर्ट किया जा सकता है। यदि आप सरणी को रिवर्स ऑर्डर में सॉर्ट करना चाहते हैं, तो आप इस विधि के इनपुट के लिए दूसरे पैरामीटर के रूप में Collections.reverseOrder () पास कर सकते हैं।

उदाहरण के लिए, एक ऐसा सरणी है जिसे हम सीधे और फिर रिवर्स ऑर्डर में क्रमबद्ध करते हैं:

 String[] someArray = new String[]{"b", "a", "c"}; Arrays.sort(someArray); System.out.println(Arrays.toString(someArray)); Arrays.sort(someArray, Collections.reverseOrder()); System.out.println(Arrays.toString(someArray)); 

निष्कर्ष इस प्रकार होगा:

 [ए, बी, सी] 
 [सी, बी, ए] 

प्रत्यक्ष और रिवर्स सॉर्टिंग के अलावा, कभी-कभी ऐसा होता है कि आपको मामले की परवाह किए बिना स्ट्रिंग्स की एक सरणी को सॉर्ट करने की आवश्यकता होती है। यह Arrays.sort के दूसरे पैरामीटर के रूप में String.CASE_INSENSITIVE_ORDER पास करके करना आसान है।

संग्रह.सॉर्ट , दुर्भाग्य से, केवल सूची कार्यान्वयन को हल करने की अनुमति देता है।

क्या एल्गोरिथ्म जावा की तरह है?

जावा में छंटनी के बारे में बात करते समय अंतिम बात यह है कि जावा में "सरल प्रकार" का उपयोग सबसे सरल प्रकारों के लिए किया जाता है, और वस्तुओं के लिए "स्थिर मर्ज" का उपयोग किया जाता है। इसलिए आपको छँटाई विधि के अपने कार्यान्वयन को विकसित करने पर संसाधनों को खर्च नहीं करना चाहिए जब तक कि प्रोफाइलर यह नहीं दिखाता कि यह आवश्यक है।

क्या होगा यदि हमारे पास एक सरणी है और विधि Iterable को स्वीकार करती है?

मैं अब ऐसे प्रश्न पर आगे बढ़ने का प्रस्ताव करता हूं, जिसमें एक सरणी को एक विधि से पारित करना है जिसमें Iterable की आवश्यकता होती है । आपको याद दिला दूं कि Iterable एक इंटरफ़ेस है जिसमें इट्रेटर () विधि है, जिसे Iterator को वापस करना चाहिए।

यदि कोई ऐसी विधि है जो इनपुट पर Iterable को स्वीकार करती है, तो सरणी को उस तरह स्थानांतरित नहीं किया जा सकता है। यद्यपि आप लूप के लिए एक सरणी पर पुनरावृति कर सकते हैं, यह Iterable नहीं है।

 String[] someArray = new String[]{"a", "b", "c"}; for (String currentString : someArray) { ... } 

इस उदाहरण में, सब कुछ ठीक है। लेकिन अगर कोई विधि है:

 private static void someIteration(Iterable<String> iterable) { ... } 

वह पंक्ति संकलित नहीं होगी:

 someIteration(someArray); 

इस स्थिति में एकमात्र तरीका सरणी को एक संग्रह में बदलना है और पहले से ही इस तरह की विधि को खिलाना है।

संक्षेप में कुछ उपयोगी संग्रह विधियों के बारे में

पढ़ने लायक क्या है?

यह उपकरण का केवल एक छोटा सा हिस्सा है जो डेटा संरचनाओं के साथ काम करते समय डेवलपर के लिए जीवन को आसान बना सकता है। संग्रह के काम में कई दिलचस्प बिंदु स्वयं और उनके साथ काम करने के लिए सुविधाजनक उपकरण ब्रूस एकेल की पुस्तक "जावा दर्शन" (4 पूर्ण संस्करण) में पाए जा सकते हैं। हालाँकि, आपको सावधान रहना चाहिए, क्योंकि यह उन स्थितियों का सामना करता है जो अब जावा 7, जावा 8 और उच्चतर पर नहीं खेली जा सकती हैं। हालांकि इस पुस्तक में जावा 6 का वर्णन किया गया है, लेकिन इसकी सामग्री आज भी काफी हद तक प्रासंगिक है।

बेशक, "जावा दर्शन" सीमित नहीं होना चाहिए। इन पुस्तकों को पढ़ने से किसी भी जावा डेवलपर को नुकसान नहीं होगा:

• «जावा। प्रभावी प्रोग्रामिंग, “यहोशू बलोच।
• "पुनर्रचना। मौजूदा कोड के डिजाइन में सुधार, "मार्टिन फाउलर।
• “साफ कोड। निर्माण, विश्लेषण और refactoring ”, रॉबर्ट मार्टिन।
• पेशेवरों के लिए स्प्रिंग 5, जूलियन कोज़मिन और अन्य।
• "टेस्ट-प्रेरित जावा डेवलपमेंट", विक्टर फारसिक, एलेक्स गार्सिया (अभी तक रूसी में जारी नहीं किया गया है)।

परिणाम क्या है?

यदि आप ऐसे दिलचस्प विचारों के साथ आए हैं जो इस लेख में लिखे गए पूरक का पूरक हो सकते हैं, तो उन्हें टिप्पणियों में साझा करें।

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

आपका ध्यान के लिए धन्यवाद। मुझे खुशी होगी अगर प्रस्तुत कोई भी उपयोगी होगा।
सभी सफलता!