تصويرن ۾ 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 تي نقل ڪيو ويندو آهي. پوء اسان جو نئون عنصر ان جي جاء تي داخل ڪيو ويندو. اڳوڻو عنصر (bugatti) اڳ ۾ ئي نقل ڪيو ويو آهي اتان کان نئين پوزيشن ۾. هاڻي اچو ته ڏسو ته اهو عمل ڪيئن ٿئي ٿو جيڪڏهن صف ۾ نوان عنصر داخل ڪرڻ لاءِ ڪي به هنڌ نه آهن. قدرتي طور تي، اتي پهرين هڪ چيڪ آهي ڏسڻ لاء ته ڇا ڪافي جاء آهي. جيڪڏهن ڪافي ڪمرو نه آهي، ته پوءِ هڪ نئين صف اندر ٺاهي ويندي آهي ArrayListجنهن جي سائيز پراڻي صف جي ڀيٽ ۾ 1.5 پلس 1 آهي، اسان جي صورت ۾، نئين سر جي سائيز 16 هوندي. سڀ موجوده عناصر اتي نقل ڪيا ويندا. فوري طور. پراڻي صف کي ردي جي ڪليڪٽر طرفان ختم ڪيو ويندو، ۽ صرف نئين، وڌايل صف باقي رهندي. هاڻي اتي هڪ نئين عنصر لاء ڪمرو آهي. اسان ان کي پوزيشن 3 تي داخل ڪري رهيا آهيون، جيڪو قبضو ڪيو ويو آهي. هاڻي واقف عمل شروع ٿئي ٿو. سڀ عناصر، انڊيڪس 3 سان شروع ٿي، ھڪڙي پوزيشن کي ساڄي طرف منتقل ڪيو ويو آھي، ۽ نئون عنصر خاموشيء سان شامل ڪيو ويو آھي. ۽ اندراج ٿي چڪو آهي! ۽ اسان داخل ڪرڻ سان ڪيو آهي. هاڻي اچو ته شيون ختم ڪرڻ بابت ڳالهايون . توهان کي ياد هوندو ته اسان هڪ مسئلي ۾ ڀڄي ويا هئاسين جڏهن صفن سان ڪم ڪندي: عناصر کي هٽائڻ هڪ صف ۾ "سوراخ" ٺاهيندو آهي. ٻاهر نڪرڻ جو واحد رستو هر هٽائڻ سان ڇڏيل شيون تبديل ڪرڻ هو ، ۽ هن شفٽ کي انجام ڏيڻ لاءِ هر ڀيري اسان کي پنهنجو ڪوڊ لکڻو هو. ArrayList ساڳئي اصول تي عمل ڪري ٿو، پر اهو اڳ ۾ ئي هن ميڪانيزم کي لاڳو ڪري ٿو. اهو ڪيئن ڏسڻ ۾ اچي ٿو: ۽ آخر ۾ اسان حاصل ڪريون ٿا جيڪو اسان چاهيون ٿا: عنصر lamboهٽايو ويو آهي. هتي اسان هڪ عنصر کي وچ مان ڪڍي ڇڏيو. واضح طور تي، فهرست جي آخر کان هڪ عنصر کي هٽائڻ تيز آهي، ڇاڪاڻ ته عنصر صرف هٽايو ويو آهي بغير سڀني کي منتقل ڪرڻ جي ضرورت کان سواء. اچو ته هڪ لمحي لاءِ ٻيهر ڳالهايون اندروني صفن جي طول و عرض جي باري ۾ ۽ اهو ڪيئن ميموري ۾ ترتيب ڏنو ويو آهي. ھڪڙي صف کي وڌائڻ لاء ڪجھ وسيلا وٺن ٿا. ArrayListانهي جي مطابق، ڊفالٽ سائيز سان نه ٺاهيو جيڪڏهن توهان کي پڪ آهي ته ان ۾ گهٽ ۾ گهٽ 100 عنصر هوندا. اندروني صف کي 6 ڀيرا وڌايو وڃي ها جڏهن توهان 100 هين عنصر داخل ڪيو، ۽ سڀني عناصر کي هر دفعي منتقل ڪرڻو پوندو.

• 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(). اهو طريقو اندروني صف جي ڊيگهه کي "ٽيم" ڪري ٿو ان ۾ موجود عناصر جي تعداد تائين. هاڻي اسان صرف ايترو ئي مختص ڪيو آهي جيترو اسان کي ضرورت آهي! :)