जावा ऐरेलिस्ट

नमस्ते! पिछले पाठों में, हमने सरणियों में गहरा गोता लगाया और सरणियों के साथ काम करने के सामान्य उदाहरणों की समीक्षा की। इस पाठ में, हम Java ArrayList की गहन समीक्षा करेंगे। सामान्य तौर पर, सरणियाँ सुपर हैंडी होती हैं। और, जैसा कि आपने पहले ही देखा है, आप उनके साथ बहुत कुछ कर सकते हैं :) लेकिन सरणियों में कई कमियाँ हैं।

• सीमित आकार। आपको यह जानने की जरूरत है कि जब आप इसे बनाते हैं तो आपकी सरणी में कितने तत्व शामिल होने चाहिए। यदि आप कम आंकते हैं, तो आपके पास पर्याप्त जगह नहीं होगी। ओवरएस्टीमेट, और एरे आधा-खाली रहेगा, जो कि खराब भी है। आखिरकार, आप अभी भी आवश्यकता से अधिक मेमोरी आवंटित कर रहे हैं।


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


• किसी आइटम को हटाने का कोई तरीका नहीं है। एक मान केवल "शून्य आउट" हो सकता है।

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

      
      
       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

आउटपुट: [बिल्ली {नाम = 'थॉमस'}, नल, बिल्ली {नाम = 'लियोनेल मेसी'}] सौभाग्य से, जावा के निर्माता सरणियों के फायदे और नुकसान से अच्छी तरह वाकिफ हैं, और इसलिए उन्होंने जावा ऐरेलिस्ट नामक एक बहुत ही दिलचस्प डेटा संरचना बनाई । जितना संभव हो उतना आसान बोलते हुए, जावा ऐरेलिस्ट एक "सूप अप" सरणी है जिसमें बहुत सी नई सुविधाएं हैं।

कैसे एक ArrayList बनाने के लिए

इसे बनाना बहुत ही आसान है:

ArrayList<Cat> cats = new ArrayList<Cat>();

अब हमने कैट ऑब्जेक्ट्स को स्टोर करने के लिए एक सूची बनाई है। ध्यान दें कि हम ArrayList का आकार निर्दिष्ट नहीं कर रहे हैं , क्योंकि यह स्वचालित रूप से विस्तृत हो सकता है। यह कैसे संभव है? वास्तव में यह काफी सरल है। यह आपको आश्चर्यचकित कर सकता है, लेकिन जावा में ArrayList एक बहुत ही साधारण सरणी के ऊपर बनाया गया है :) हाँ, इसमें एक सरणी है, और यहीं पर हमारे तत्व संग्रहीत हैं। लेकिन जावा में ArrayList के पास उस सरणी के साथ काम करने का एक विशेष तरीका है:

• जब आंतरिक सरणी भर जाती है, तो ArrayList आंतरिक रूप से एक नई सरणी बनाता है। नई सरणी का आकार 1.5 प्लस 1 के पुराने सरणी के आकार का आकार है।


• सभी डेटा को पुराने एरे से नए में कॉपी किया जाता है


• पुराने एरे को कचरा संग्राहक द्वारा साफ किया जाता है।

यह तंत्र नए तत्वों को जोड़ने के लिए एक विधि को लागू करने के लिए जावा ऐरेलिस्ट (सामान्य सरणी के विपरीत) की अनुमति देता है। यह add()तरीका है

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

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

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

आउटपुट: 0 यह सही है। हमारा थॉमस ऑब्जेक्ट वास्तव में तत्व 0 में संग्रहीत है। सारणियों में केवल कमियां नहीं हैं। उनके निर्विवाद फायदे भी हैं। उनमें से एक इंडेक्स द्वारा तत्वों को खोजने की क्षमता है। क्योंकि हम एक इंडेक्स की ओर इशारा करते हैं, यानी एक विशिष्ट मेमोरी एड्रेस की ओर, इस तरह से एक ऐरे को खोजना बहुत तेज है। ArrayListकरना भी जानता है! प्राप्त () विधि इसे लागू करती है:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

आउटपुट: कैट {नाम = 'बेहेमोथ'} इसके अलावा, आप आसानी से पता लगा सकते हैं कि क्या ArrayList में कोई विशेष वस्तु है। यह ArrayList में शामिल () विधि का उपयोग करके किया जाता है:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

विधि जाँचती है कि क्या ArrayList के आंतरिक सरणी में तत्व है, और एक बूलियन (सही या गलत) लौटाता है। आउटपुट: झूठा और सम्मिलन के बारे में एक और महत्वपूर्ण बात। ArrayList आपको न केवल सरणी के अंत में, बल्कि कहीं भी तत्वों को सम्मिलित करने के लिए एक इंडेक्स का उपयोग करने देता है। इसके लिए इसके दो तरीके हैं:

• ऐरेलिस्ट ऐड (इंट इंडेक्स, कैट एलिमेंट)
• ऐरेलिस्ट सेट (इंट इंडेक्स, कैट एलिमेंट)

तर्कों के रूप में, ये दोनों विधियाँ उस स्थिति का सूचकांक लेती हैं जहाँ आप सम्मिलित करना चाहते हैं, और स्वयं वस्तु का संदर्भ। अंतर यह है कि सेट () का उपयोग करके सम्मिलित करना पुराने मान को अधिलेखित कर देता है। ऐड () का उपयोग करके सम्मिलित करना पहले [इंडेक्स] से सभी तत्वों को सरणी के अंत में स्थानांतरित करता है, और फिर परिणामी खाली स्थिति में निर्दिष्ट ऑब्जेक्ट जोड़ता है।

यहाँ एक उदाहरण है:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

आउटपुट: [[बिल्ली {नाम = 'थॉमस'}, बिल्ली {नाम = 'बेहेमोथ'}] [बिल्ली {नाम = 'लियोनेल मेस्सी'}, बिल्ली {नाम = 'बेहेमोथ'}] हमारे पास 2 बिल्लियों की एक सूची थी । फिर हमने सेट () विधि का उपयोग करके दूसरे को तत्व 0 के रूप में डाला । नतीजतन, पुराने तत्व को एक नए से बदल दिया गया है।

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

और यहाँ हम देखते हैं कि ऐड () अलग तरह से काम करता है। यह सभी तत्वों को दाईं ओर ले जाता है और फिर नए मान को तत्व 0 के रूप में लिखता है। आउटपुट: [बिल्ली {नाम = 'थॉमस'}, बिल्ली {नाम = 'बेहेमोथ'}] [बिल्ली {नाम = 'लियोनेल मेस्सी'}, कैट {नाम = 'थॉमस'}, कैट {नाम = 'बेहेमोथ'}] सूची को पूरी तरह से साफ़ करने के लिए, हम स्पष्ट () विधि का उपयोग करते हैं:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

आउटपुट: [] सब कुछ सूची से हटा दिया गया। वैसे, कृपया ध्यान दें: सरणियों के विपरीत, ArrayList toString() विधि को ओवरराइड करता है और सूची को पहले से ही स्ट्रिंग के रूप में प्रदर्शित करता है। साधारण सरणियों के साथ, हमें इसके लिए Arrays वर्ग का उपयोग करना पड़ा। और चूंकि मैंने Arrays का उल्लेख किया है : जावा आपको आसानी से एक सरणी और ArrayList के बीच "स्विच" करने देता है , यानी एक को दूसरे में परिवर्तित करता है। इसके लिए Arrays वर्ग के पास Arrays.asList () विधि है। हम सामग्री को सरणी के रूप में प्राप्त करने के लिए इसका उपयोग करते हैं और उन्हें हमारे ArrayList कन्स्ट्रक्टर में पास करते हैं:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

आउटपुट: [बिल्ली {नाम = 'थॉमस'}, बिल्ली {नाम = 'बेहेमोथ'}, बिल्ली {नाम = 'लियोनेल मेस्सी'}, बिल्ली {नाम = 'शराबी'}] आप विपरीत दिशा में भी जा सकते हैं: प्राप्त करें एक ArrayList वस्तु से एक सरणी । हम इसे toArray() विधि का उपयोग करके करते हैं:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

नोट: हमने toArray () विधि के लिए एक खाली सरणी पारित की । यह एक त्रुटि नहीं है। ArrayList वर्ग के अंदर , यह विधि इस तरह से कार्यान्वित की जाती है कि एक खाली सरणी पास करने से इसका प्रदर्शन बढ़ जाता है। बस इसे भविष्य के लिए ध्यान में रखें (बेशक, आप कुछ विशिष्ट आकार की एक सरणी पास कर सकते हैं; वह भी काम करेगा)। ओह, आकार के बारे में। सूची का वर्तमान आकार आकार () विधि का उपयोग करके पाया जा सकता है:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

यह समझना महत्वपूर्ण है कि सरणी की लंबाई संपत्ति के विपरीत, ArrayList.size() विधि तत्वों की वास्तविक संख्या लौटाती है, मूल क्षमता नहीं। आखिरकार, हमने ArrayList बनाते समय आकार निर्दिष्ट नहीं किया । हालाँकि, आप इसे निर्दिष्ट कर सकते हैं - ArrayList के पास एक उपयुक्त कंस्ट्रक्टर है। लेकिन नए तत्वों को जोड़ने के मामले में, यह अपना व्यवहार नहीं बदलता है:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

कंसोल आउटपुट: 4 हमने 2 तत्वों की एक सूची बनाई है, लेकिन जब हमें इसकी आवश्यकता होती है तो यह चुपचाप विस्तारित हो जाती है। एक और विचार यह है कि यदि हम शुरुआत में एक बहुत छोटी सूची बनाते हैं, तो इसे अधिक बार विस्तारित करना होगा, जिसमें कुछ संसाधनों का उपयोग होगा। हमने इस पाठ में ArrayList से तत्वों को हटाने की प्रक्रिया को शायद ही छुआ है , ऐसा इसलिए नहीं है क्योंकि यह हमारे दिमाग से फिसल गया है। हमने इस विषय को एक अलग पाठ में रखा है जिसे आप बाद में मिलेंगे :) आपने जो सीखा है उसे सुदृढ़ करने के लिए, हम आपको हमारे जावा कोर्स से एक वीडियो सबक देखने का सुझाव देते हैं