تصویروں میں جاوا اری لسٹ

ہیلو! آج کا لیکچر ArrayListایک طرف سادہ اور دوسری طرف پچھلے لیکچر سے زیادہ مشکل ہوگا۔ یہ زیادہ مشکل ہے، کیونکہ آج ہم "ہڈ کے نیچے" دیکھیں گے ArrayListاور مطالعہ کریں گے کہ آپریشن کے دوران اس کے ساتھ کیا ہوتا ہے۔ دوسری طرف، اس لیکچر میں تقریباً کوئی کوڈ نہیں ہوگا - زیادہ تر تصاویر اور وضاحتیں۔ تو، چلیں :) جیسا کہ آپ پہلے ہی جانتے ہیں، ArrayList'a کے اندر ایک عام صف ہے، جو ڈیٹا اسٹور کے طور پر کام کرتی ہے۔ زیادہ تر معاملات میں، ہم فہرست کے صحیح سائز کی وضاحت نہیں کرتے ہیں۔ لیکن اندرونی صف کا کچھ سائز ہونا ضروری ہے! یہ حقیقت ہے. اس کا ڈیفالٹ سائز [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()۔ یہ اندرونی صف کی لمبائی کو فی الحال اس میں ذخیرہ شدہ عناصر کی تعداد تک "کاٹتا ہے"۔ اب جتنی میموری ضرورت ہے مختص ہے! :)