Java 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);//добавляем ford в ячейку 1, которая уже занята
}

ٻيهر، اهو پهريون ڀيرو چيڪ ڪري ٿو ته ڇا صف ۾ ڪافي جاء آهي. جيڪڏهن ڪافي جاء آهي، عناصر کي سيل کان شروع ٿيندڙ ساڄي طرف منتقل ڪيو ويو آهي جتي اسان نئون عنصر داخل ڪندا آهيون. اسان انڊيڪس 1 سان سيل ۾ پيسٽ ڪريون ٿا. يعني سيل 3 مان عنصر سيل 4 ۾، عنصر 2 کان سيل 3 ۾، عنصر 1 کان سيل 2 ۾ نقل ڪيو ويو آهي. ان کان پوء، اسان جو نئون عنصر جاء تي پيسٽ ڪيو ويندو. اڳوڻو عنصر ( bugatti) اڳ ۾ ئي نقل ڪيو ويو آھي اتان کان نئين جڳھ ڏانھن. هاڻي اچو ته اهو سمجهون ته اهو عمل ڪيئن ٿيندو جيڪڏهن صف ۾ داخل ڪرڻ جي گنجائش نه هجي. پهرين، يقينا، هڪ چيڪ ڪيو ويو آهي ڏسڻ لاء ته ڪافي جاء آهي. جيڪڏهن اهو ظاهر ٿئي ٿو ته ڪافي جاء نه آهي، ArrayListسائيز جي هڪ نئين سري (OldArray * 1.5 جي ماپ) + 1 اندر ٺاهي وئي آهي 'a. اسان جي صورت ۾، نئين سري جي سائيز 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(). اهو اندروني صف جي ڊيگهه کي "ڪٽ" ڪري ٿو ان ۾ موجود عناصر جي تعداد تائين. هاڻي ضرورت جيتري ياداشت مختص ڪئي وئي آهي! :)