चित्रों में ArrayList

नमस्ते! आज का पाठ 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 में कॉपी किया जाता है। फिर हमारे नए तत्व को इसके स्थान पर डाला जाता है। पिछले तत्व (बुगाटी) को वहां से नए स्थान पर पहले ही कॉपी कर लिया गया है। अब देखते हैं कि यह प्रक्रिया कैसे होती है यदि सरणी में नए तत्वों को सम्मिलित करने के लिए कोई स्थान नहीं है। स्वाभाविक रूप से, यह देखने के लिए पहले एक जांच होती है कि पर्याप्त जगह है या नहीं। यदि पर्याप्त जगह नहीं है, तो अंदर एक नई सरणी बनाई जाती है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 तत्वों की एक सरणी के लिए मेमोरी एक साथ आवंटित की जाएगी, जिससे सरणी अधिक कुशल हो जाएगी (इसे विस्तारित करने की आवश्यकता नहीं होगी)। इस रणनीति का एक दूसरा पहलू भी है। जब आप ऑब्जेक्ट को a से हटाते हैं ArrayList, तो आंतरिक सरणी का आकार स्वचालित रूप से कम नहीं होता है। मान लें कि हमारे पास ArrayList88 तत्वों की पूरी तरह से आंतरिक सरणी है: जैसे ही प्रोग्राम चलता है, हम 77 तत्वों को हटा देते हैं, इसलिए केवल 11 शेष रहते हैं: क्या आपने पहले ही अनुमान लगाया है कि समस्या क्या है? आप समझ गए, स्मृति का अक्षम उपयोग! हम यहां केवल 11 पदों का उपयोग कर रहे हैं, लेकिन हमने 88 तत्वों के लिए मेमोरी आवंटित की है। यह हमारी जरूरत से 8 गुना ज्यादा है! इस मामले में, हम ArrayListकक्षा के विशेष तरीकों में से एक के साथ अपने मेमोरी उपयोग को अनुकूलित कर सकते हैं:trimToSize(). यह विधि वर्तमान में संग्रहीत तत्वों की संख्या के लिए आंतरिक सरणी की लंबाई को "ट्रिम" करती है। अब हमने केवल उतनी ही मेमोरी आवंटित की है जितनी हमें चाहिए! :)