चित्रांमध्ये अॅरेलिस्ट

हाय! आजचा धडा ArrayListमागील धड्यांपेक्षा सोपा आणि कठीण दोन्ही असेल. ArrayListहे अधिक कठीण होईल कारण आज आपण विविध ऑपरेशन्स दरम्यान काय घडते ते पाहणार आहोत आणि त्याचा अभ्यास करणार आहोत. दुसरीकडे, या धड्यात जवळजवळ कोणताही कोड नसेल. हे मुख्यतः चित्रे आणि स्पष्टीकरण आहे. बरं, चला जाऊया :) तुम्हाला आधीच माहित आहे की, ArrayListआत एक सामान्य अॅरे आहे, जो डेटा स्टोअर म्हणून काम करतो. बहुतेक प्रकरणांमध्ये, आम्ही सूचीचा अचूक आकार निर्दिष्ट करत नाही. पण अंतर्गत अॅरेचा काही आकार असला पाहिजे! आणि तसे ते करते. त्याचा डीफॉल्ट आकार 10 आहे .

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
}

प्रथम, नवीन घटक जोडणे कसे दिसते ते पाहू. व्यवसायाचा पहिला क्रम म्हणजे अंतर्गत अॅरेमध्ये अंतर्गत अॅरेमध्ये पुरेशी जागा आहे की नाही आणि आणखी एक घटक बसेल की नाही हे तपासणे . जर जागा असेल तर सूचीच्या शेवटी नवीन घटक जोडला जाईल. जेव्हा आपण "शेवटपर्यंत" म्हणतो, तेव्हा आमचा अर्थ अॅरेमधील शेवटची स्थिती असा होत नाही (ते विचित्र असेल). आमचा अर्थ शेवटच्या वर्तमान घटकानंतरची स्थिती आहे. त्याचा निर्देशांक असेल cars.size(). आमची यादी सध्या रिकामी आहे ( cars.size() == 0). त्यानुसार, नवीन घटक स्थान 0 वर जोडला जाईल.

ArrayList<Car> cars = new ArrayList<>();
Car ferrari = new Car("Ferrari 360 Spider");
cars.add(ferrari);

ते पुरेसे स्पष्ट आहे. आपण मध्यभागी, म्हणजे इतर घटकांमध्‍ये टाकल्यास काय होईल?

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");
   Car ford = new Car("Ford Modneo");
  
   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
  
   cars.add(1, ford);// add ford to cell 1, which is already occupied
}

पुन्हा, प्रथम अॅरेमध्ये पुरेशी जागा आहे की नाही हे तपासा. पुरेशी जागा असल्यास, घटक उजवीकडे हलवले जातात , जिथे आपण नवीन घटक घालत आहोत त्या स्थितीपासून प्रारंभ होतो. आम्ही स्थान 1 वर घालत आहोत. दुसऱ्या शब्दांत, स्थान 3 मधील घटक स्थान 4 वर, घटक 2 ची स्थिती 3 वर आणि घटक 1 ची स्थिती 2 वर कॉपी केली जाते. त्यानंतर आमचा नवीन घटक त्याच्या जागी घातला जातो. मागील घटक (bugatti) आधीच तेथून नवीन स्थानावर कॉपी केले गेले आहे. आता अॅरेमध्ये नवीन घटक घालण्यासाठी जागा नसल्यास ही प्रक्रिया कशी होते ते पाहू. स्वाभाविकच, पुरेशी जागा आहे की नाही हे पाहण्यासाठी प्रथम तपासणी केली जाते. पुरेशी जागा नसल्यास, आत एक नवीन अॅरे तयार केला जातोArrayListज्याचा आकार जुन्या अॅरेच्या वेळा 1.5 अधिक 1 चा आकार आहे आमच्या बाबतीत, नवीन अॅरेचा आकार 16 असेल. सध्याचे सर्व घटक तेथे लगेच कॉपी केले जातील. जुना अॅरे कचरा गोळा करणाऱ्याद्वारे हटवला जाईल आणि फक्त नवीन, विस्तारित अॅरे राहील. आता नवीन घटकासाठी जागा आहे. आम्ही ते स्थान 3 वर घालत आहोत, जे व्यापलेले आहे. आता परिचित प्रक्रिया सुरू होते. अनुक्रमणिका 3 पासून सुरू होणारे सर्व घटक एक स्थान उजवीकडे हलवले जातात आणि नवीन घटक शांतपणे जोडले जातात. आणि प्रवेश पूर्ण झाला! आणि आम्ही समाविष्ट करणे पूर्ण केले. आता आयटम काढण्याबद्दल बोलूया . तुम्हाला आठवत असेल की अॅरेसह काम करताना आम्हाला समस्या आली: घटक काढून टाकल्याने अॅरेमध्ये "छिद्र" होतात.प्रत्येक काढण्यासोबत, आणि आम्हाला प्रत्येक वेळी हा शिफ्ट करण्यासाठी आमचा स्वतःचा कोड लिहावा लागला. ArrayList समान तत्त्वाचे पालन करते, परंतु ते आधीपासूनच ही यंत्रणा लागू करते. हे असे दिसते: आणि शेवटी आपल्याला पाहिजे ते मिळते: घटक lamboकाढून टाकला गेला आहे. येथे आपण मध्यभागी एक घटक काढला आहे. स्पष्टपणे, सूचीच्या शेवटी घटक काढून टाकणे अधिक जलद आहे, कारण घटक इतर सर्व स्थानांतरीत न करता फक्त काढून टाकला जातो. अंतर्गत अॅरेचे परिमाण आणि ते मेमरीमध्ये कसे व्यवस्थित केले जाते याबद्दल काही क्षण पुन्हा बोलूया. अॅरेचा विस्तार करण्यासाठी काही संसाधने लागतात. त्यानुसार, तयार करू नकाArrayListजर तुम्हाला खात्री असेल की त्यात किमान 100 घटक असतील तर डीफॉल्ट आकारासह. तुम्ही 100 वा घटक टाकल्यानंतर अंतर्गत अॅरे 6 वेळा वाढवावी लागेल आणि प्रत्येक वेळी सर्व घटक हलवावे लागतील.

• 10 घटकांपासून 16 पर्यंत
• 16 घटकांपासून 25 पर्यंत
• 25 ते 38 पर्यंत
• 38 ते 58 पर्यंत
• 58 ते 88 पर्यंत
• 88 ते 133 पर्यंत (म्हणजे जुन्या अॅरे वेळा 1.5 अधिक 1 चा आकार)

जसे आपण कल्पना करू शकता, हे खूप संसाधन-केंद्रित आहे. म्हणून, जर तुम्हाला आधीच (अगदी अंदाजे) आयटमची आवश्यक संख्या माहित असेल तर, विशिष्ट आकाराच्या अॅरेसह सूची तयार करणे चांगले आहे:

ArrayList<Car> cars = new ArrayList<>(100);

आता 100 घटकांच्या अॅरेसाठी मेमरी एकाच वेळी वाटप केली जाईल, अॅरे अधिक कार्यक्षम बनवेल (त्याला विस्तारित करण्याची आवश्यकता नाही). या रणनीतीला एक फ्लिप बाजू देखील आहे. जेव्हा तुम्ही मधून ऑब्जेक्ट्स काढता तेव्हा ArrayListअंतर्गत अॅरेचा आकार आपोआप कमी होत नाही. समजा आमच्याकडे ArrayList88 घटकांची संपूर्ण अंतर्गत अ‍ॅरे आहे: जसजसा प्रोग्राम चालतो, तसतसे आम्ही 77 घटक काढून टाकतो, त्यामुळे फक्त 11 शिल्लक राहतात: तुम्ही आधीच अंदाज लावला आहे की समस्या काय आहे? तुम्हाला समजले, मेमरीचा अकार्यक्षम वापर! आम्ही येथे फक्त 11 पोझिशन्स वापरत आहोत, परंतु आम्ही 88 घटकांसाठी मेमरी वाटप केली आहे. ते आमच्या गरजेपेक्षा 8 पट जास्त आहे! या प्रकरणात, आम्ही आमच्या मेमरी वापरास वर्गाच्या एका ArrayListविशेष पद्धतीसह अनुकूल करू शकतो:trimToSize(). ही पद्धत अंतर्गत अॅरेची लांबी त्यामध्ये सध्या साठवलेल्या घटकांच्या संख्येपर्यंत कमी करते. आता आम्ही फक्त आवश्यक तेवढी मेमरी वाटप केली आहे! :)