Java ArrayList

हाय! मागील धड्यांमध्‍ये, आम्‍ही अॅरेमध्‍ये सखोल डुबकी मारली आणि अॅरेसोबत काम करण्‍याच्‍या सामान्य उदाहरणांचे पुनरावलोकन केले. या धड्यात, आम्ही 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 + '\'' +
               '}';
   }
}

आउटपुट: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] सुदैवाने, Java च्या निर्मात्यांना अ‍ॅरेचे फायदे आणि तोटे माहित आहेत आणि म्हणूनच Java ArrayList नावाची एक अतिशय मनोरंजक डेटा रचना तयार केली आहे . शक्य तितक्या सोप्या भाषेत सांगायचे तर, Java ArrayList हा अनेक नवीन वैशिष्ट्यांसह "सूप अप" अॅरे आहे.

अॅरेलिस्ट कशी तयार करावी

ते तयार करणे खूप सोपे आहे:

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

आता आम्ही कॅट ऑब्जेक्ट्स साठवण्यासाठी एक सूची तयार केली आहे . लक्षात घ्या की आम्ही ArrayList चा आकार निर्दिष्ट करत नाही , कारण ते आपोआप विस्तारू शकते. हे कसे शक्य आहे? हे अगदी सोपे आहे, प्रत्यक्षात. हे तुम्हाला आश्चर्यचकित करू शकते, परंतु Java मधील ArrayList अगदी सामान्य अॅरेच्या वर बनवलेले आहे :) होय, त्यात अॅरे आहे आणि तिथेच आमचे घटक साठवले जातात. परंतु Java मधील ArrayList मध्ये त्या अॅरेसह काम करण्याचा विशेष मार्ग आहे:

• जेव्हा अंतर्गत अॅरे भरले जाते, तेव्हा अॅरेलिस्ट अंतर्गत एक नवीन अॅरे तयार करते. नवीन अॅरेचा आकार जुन्या अॅरेच्या गुणाकार 1.5 अधिक 1 आहे.


• सर्व डेटा जुन्या अॅरेमधून नवीनमध्ये कॉपी केला जातो


• कचरा वेचणाऱ्यांकडून जुनी अॅरे साफ केली जाते.

ही यंत्रणा Java ArrayList (सामान्य अॅरेच्या विपरीत) नवीन घटक जोडण्यासाठी पद्धत लागू करण्यास अनुमती देते. ती add()पद्धत आहे

public static void main(String[] args) {

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

सूचीच्या शेवटी नवीन आयटम जोडले जातात. आता अॅरे ओव्हरफ्लो होण्याचा कोणताही धोका नाही, त्यामुळे ही पद्धत पूर्णपणे सुरक्षित आहे. तसे, 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);

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

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

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);
}

आउटपुट: Cat{name='Behemoth'} याशिवाय, ArrayList मध्ये विशिष्ट ऑब्जेक्ट आहे की नाही हे तुम्ही सहजपणे शोधू शकता. हे ArrayList contains() पद्धत वापरून केले जाते:

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 च्या अंतर्गत अॅरेमध्ये घटक आहे की नाही हे तपासते आणि बुलियन (सत्य किंवा असत्य) मिळवते. आउटपुट: असत्य आणि समाविष्ट करण्याबद्दल आणखी एक महत्त्वाची गोष्ट. अॅरेलिस्ट तुम्हाला केवळ अॅरेच्या शेवटीच नाही तर कुठेही घटक घालण्यासाठी इंडेक्स वापरू देते. यासाठी दोन पद्धती आहेत:

• अॅरेलिस्ट अॅड (इंट इंडेक्स, मांजर घटक)
• अॅरेलिस्ट सेट (इंट इंडेक्स, मांजर घटक)

आर्ग्युमेंट्स म्हणून, या दोन्ही पद्धती तुम्ही जिथे घालू इच्छिता त्या स्थितीची अनुक्रमणिका आणि ऑब्जेक्टचाच संदर्भ घेतात. फरक हा आहे की set() वापरून टाकल्याने जुने मूल्य ओव्हरराईट होते. add() वापरून टाकल्याने प्रथम सर्व घटक [index] पासून अॅरेच्या शेवटी शिफ्ट होतात आणि नंतर निर्दिष्ट ऑब्जेक्ट परिणामी रिकाम्या स्थितीत जोडतात.

येथे एक उदाहरण आहे:

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());
}

आणि येथे आपण पाहतो की add() वेगळ्या पद्धतीने कार्य करते. ते सर्व घटक उजवीकडे हलवते आणि नंतर घटक 0 म्हणून नवीन मूल्य लिहिते. आउटपुट: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] यादी पूर्णपणे साफ करण्यासाठी, आम्ही clear() पद्धत वापरतो:

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());
}

आउटपुट: [] सर्व काही सूचीमधून काढले गेले. तसे, कृपया लक्षात ठेवा: अॅरेच्या विपरीत, अॅरेलिस्ट toString() पद्धतीला ओव्हरराइड करते आणि आधीच स्ट्रिंग म्हणून योग्यरित्या सूची प्रदर्शित करते. सामान्य अ‍ॅरेसह, आम्हाला यासाठी अ‍ॅरे वर्ग वापरावा लागला. आणि मी Arrays चा उल्लेख केल्यापासून : Java तुम्हाला अॅरे आणि ArrayList मध्ये सहज "स्विच" करू देते , म्हणजे एक दुसऱ्यामध्ये रूपांतरित करू शकते. Arrays वर्गात यासाठी Arrays.asList() पद्धत आहे . आम्‍ही याचा वापर अॅरे म्‍हणून सामग्री मिळवण्‍यासाठी करतो आणि ती आमच्या अॅरेलिस्ट कन्स्ट्रक्‍टरकडे देतो:

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 मधून घटक काढून टाकण्याच्या प्रक्रियेला फारसा स्पर्श केला नाही . अर्थातच, यामुळे आमचे मन घसरले असे नाही. आम्ही हा विषय एका वेगळ्या धड्यात ठेवला आहे जो तुम्ही नंतर भेटू शकाल :) तुम्ही जे शिकलात ते अधिक मजबूत करण्यासाठी, आम्ही तुम्हाला आमच्या Java कोर्समधून व्हिडिओ धडा पाहण्याची शिफारस करतो.