जावा में संग्रह वर्ग

नमस्ते! पिछले कुछ पाठों में, हमने अपनी महारत में काफी प्रगति की है ArrayList। हालाँकि, अब तक हमने केवल सबसे सरल ऑपरेशन किए हैं: हटाना, सम्मिलित करना और प्रदर्शित करना। बेशक, यह उन कार्यों की पूरी सूची को कवर नहीं करता है जो डेवलपर्स को काम करते समय करना चाहिए ArrayList। सरणियों और वर्ग के बारे में पाठ याद रखें Arrays? जावा के रचनाकारों ने विशेष रूप से इस वर्ग को सरणियों के साथ काम करते समय प्रोग्रामर द्वारा सामना किए जाने वाले सबसे सामान्य कार्यों को संभालने के लिए डिज़ाइन किया है। और क्या इस बारे मेंArrayList? निश्चित रूप से, इसके साथ किए जाने वाले सामान्य कार्यों की कुछ सूची है। क्या वे सभी एक विशिष्ट वर्ग में लागू किए गए हैं, या क्या हमें हर बार अपना स्वयं का कार्यान्वयन लिखना है? बेशक, आपको खुद सब कुछ लिखने की जरूरत नहीं है। संग्रह से जुड़े सबसे आम संचालन विशेष स्थैतिक Collectionsवर्ग में पहले ही लागू किए जा चुके हैं। जावा में, डेटा संरचनाओं के एक समूह को आमतौर पर एक संग्रह के रूप में संदर्भित किया जाता है । डेटा को कई अलग-अलग तरीकों से स्टोर किया जा सकता है। अब तक, हमने केवल उस ArrayListवर्ग का अध्ययन किया है, जहाँ डेटा को एक ऐरे में संग्रहीत किया जाता है। हम बाद में अन्य संग्रहों से परिचित होंगे। अभी के लिए, यह समझने के लिए पर्याप्त है कि Collectionsकक्षा को न केवल काम करने के लिए डिज़ाइन किया गया हैArrayList, बल्कि अन्य प्रकार के संग्रहों के साथ भी (इसलिए, इसका नाम)। Collectionsतो, काम करते समय कक्षा वास्तव में किन कार्यों में मदद करती है ArrayList? पहली और सबसे स्पष्ट छँटाई है। सरणियों के पाठ में, हमने संख्याओं के साथ एक उदाहरण पर विचार किया। अब हम स्ट्रिंग्स के साथ एक उदाहरण पर विचार करेंगे। वर्ग संग्रह की सामग्री को छाँटने की विधि को Collectionsलागू करता है :sort()

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       System.out.println(solarSystem);

   }
}

आउटपुट: [पृथ्वी, बृहस्पति, मंगल, बुध, नेपच्यून, शनि, यूरेनस, शुक्र] तार वर्णानुक्रम में क्रमबद्ध हैं! लेकिन वर्णानुक्रम में क्यों? वर्ग Stringवास्तव में उस तर्क को लागू करता है जो यह नियंत्रित करता है कि तार की तुलना कैसे की जाती है (जो वर्णानुक्रम में होता है)। उन कक्षाओं के लिए जिन्हें आप स्वयं बनाते हैं, आप अपने स्वयं के तुलना तर्क को लागू कर सकते हैं, लेकिन हम इसके बारे में अन्य पाठों में बात करेंगे। कक्षा Collectionsआपको एक में न्यूनतम और अधिकतम तत्व खोजने में भी मदद करती है ArrayList। यह min()और max()विधियों का उपयोग करके किया जाता है:

public static void main(java.lang.String[] args) {

   ArrayList<Integer> numbers = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7));
   System.out.println(Collections.max(numbers));
   System.out.println(Collections.min(numbers));

}

आउटपुट: 7 1 स्वाभाविक रूप से, यह सभी तत्वों पर पुनरावृति करने और सबसे बड़ा/छोटा तत्व खोजने के लिए मैन्युअल रूप से कोड लिखने से कहीं अधिक सुविधाजनक है :) एक और बहुत उपयोगी तरीका है reverse()। अगर हमें सूची को "फ्लिप" करना होता है तो तत्व विपरीत क्रम में जाते हैं, हम इसे कैसे करेंगे? इस तरह के एक एल्गोरिथ्म को अपने आप से लिखना शायद इतना आसान नहीं होगा :) सौभाग्य से, reverse()विधि पहले से ही जानती है कि कैसे। मान लीजिए कि हम इस तथ्य को पसंद नहीं करते हैं कि sort()विधि हमारे ग्रहों को वर्णानुक्रम में क्रमबद्ध करती है, और हम उनके क्रम को उलटना चाहते हैं: Z से A तक:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune));
       Collections.sort(solarSystem);
       Collections.reverse(solarSystem);
       System.out.println(solarSystem);

   }
}

आउटपुट: [वीनस, यूरेनस, शनि, नेपच्यून, बुध, मंगल, बृहस्पति, पृथ्वी] हम छँटाई, तत्वों के क्रम आदि के बारे में बहुत सारी बातें कर रहे हैं। लेकिन अगर हमारा उद्देश्य विपरीत हो तो क्या होगा? उदाहरण के लिए, मान लीजिए कि हम एक बिंगो गेम को क्रियान्वित करने का प्रयास कर रहे हैं। हम ड्रम में 100 नंबर जोड़ते हैं। उन्हें एक-एक करके स्क्रीन पर दिखना चाहिए। अपने टिकट पर सभी नंबरों को पार करने वाला पहला खिलाड़ी जीतता है। विधि का उपयोग करके इसे कार्यान्वित करना आसान है shuffle():

public class Main {

   public static void main(java.lang.String[] args) {

       ArrayList<Integer> bingoDrum = new ArrayList<>(100);
       for (int i = 1; i <= 100; i++) {

           bingoDrum.add(i);// add the numbers 1 to 100 to the drum
       }

       Collections.shuffle(bingoDrum);// Mix it up
       System.out.println ("Your attention, please! Here are the first 10 numbers from the drum!");
       for (int i = 0; i < 10; i++) {

           System.out.println(bingoDrum.get(i));
       }

   }
}

आउटपुट: आपका ध्यान, कृपया! यहाँ ड्रम से पहले 10 नंबर हैं! 32 61 4 81 25 8 66 35 42 71 यह इतना आसान है! समस्या हल हो गई है, और खेल का हमारा हिस्सा लिखा गया है :) अब आइए एक अलग स्थिति की कल्पना करें। पहले, हमने एक solarSystemसूची बनाई थी जिसमें ग्रह शामिल थे। और ऐसा लगता है कि यह हमें हर तरह से सूट करता है लेकिन एक: आप इसमें से आइटम हटा सकते हैं और नए जोड़ सकते हैं ! यह स्पष्ट रूप से वह व्यवहार नहीं है जिसकी हम अपेक्षा करते हैं: हमारे कार्यक्रम में सौर प्रणाली अपरिवर्तनीय होनी चाहिए। कक्षा Collectionsका एक बहुत ही रोचक तरीका है: unmodifiableList(). यह एक तर्क के रूप में पारित सूची से एक अपरिवर्तनीय सूची बनाता है। आप इस सूची में आइटम जोड़ या हटा नहीं सकते हैं। सौर मंडल में ग्रहों की सूची के साथ काम करते समय, हम यही चाहते हैं!

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       List<String> solarSystem = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(mercury, venus, earth, mars,
               jupiter, saturn, uranus, neptune)));
       solarSystem.add("Pluto");// Try to add a new element
   }
}

आउटपुट: धागे में अपवाद "मुख्य" java.lang.UnsupportedOperationException पर java.util.Collections$UnmodifyingCollection.add(Collections.java:1075) at Main.main(Main.java:21) यह एक त्रुटि है: आप नहीं कर सकते कुछ भी जोड़ो solarSystem! केवल एक चीज जिस पर आपको ध्यान देने की आवश्यकता है वह यह है कि यह विधि वापस आती है List<>(नहीं ArrayList<>), क्योंकि यह प्रकार सभी प्रकार की सूचियों के लिए सामान्य है। एक और काफी सामान्य स्थिति जो आसानी से हो सकती है वह है प्रोग्रामर के लिए तत्वों को गलत क्रम में जोड़ना। यदि ऐसा होता है और हम पाते हैं कि बुध और नेपच्यून मिश्रित हैं, तो हम इस swap()विधि का उपयोग करके इस गलती को ठीक कर सकते हैं:

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystem = new ArrayList<>(Arrays.asList(neptune, venus, earth, mars
       , jupiter, saturn, uranus, mercury));// The planets are in the wrong order
       System.out.println(solarSystem);

       Collections.swap(solarSystem, solarSystem.indexOf(mercury), solarSystem.indexOf(neptune));
       System.out.println(solarSystem);

   }
}

हम swap()अपनी सूची की विधि और दो तत्वों के सूचकांकों को पास करते हैं जिन्हें स्वैप करने की आवश्यकता होती है। ध्यान दें कि विधि सूचकांकों के साथ काम करती है, संदर्भों के साथ नहीं। तो, यहाँ हमें ArrayList.indexOf()विधि का उपयोग करना पड़ा। आउटपुट: [नेपच्यून, शुक्र, पृथ्वी, मंगल, बृहस्पति, शनि, यूरेनस, बुध] [बुध, शुक्र, पृथ्वी, मंगल, बृहस्पति, शनि, यूरेनस, नेप्च्यून] अंत में, हम एक बहुत ही रोचक विधि से परिचित होंगे : disjoint()। यह जाँचता है कि क्या दो संग्रह प्रतिच्छेद करते हैं, अर्थात, क्या उनके पास कम से कम एक समान तत्व है । यदि वे नहीं करते हैं, तो यह सच हो जाता है। यह वे करते हैं, तो यह झूठा रिटर्न देता है

public class Main {

   public static void main(java.lang.String[] args) {

       String mercury = new String("Mercury");
       String venus = new String("Venus");
       String earth = new String("Earth");
       String mars = new String("Mars");
       String jupiter = new String("Jupiter");
       String saturn = new String("Saturn");
       String uranus = new String("Uranus");
       String neptune = new String("Neptune");

       ArrayList<String> solarSystemPart1 = new ArrayList<>(Arrays.asList(mercury, venus, earth, mars));
       ArrayList<String> solarSystemPart2 = new ArrayList<>(Arrays.asList(jupiter, saturn, uranus, neptune));

       System.out.println(Collections.disjoint(solarSystemPart1, solarSystemPart2));

   }
}

जैसा कि आप देख सकते हैं, हमारी दो सूचियों में पूरी तरह से अलग तत्व हैं, इसलिए प्रोग्राम सही आउटपुट देता है । यह एक रोचक और बहुत उपयोगी वर्ग है। जैसे Arrays, यह हमारे लिए बहुत से नियमित, थकाऊ काम करता है, जिससे हमें अन्य चीजों पर ध्यान केंद्रित करने में मदद मिलती है।