جاوا میں ArrayList کلاس

ہیلو! پچھلے لیکچرز میں، ہم نے اس طرح کے ڈیٹا ڈھانچے کا ایک صف کے طور پر تفصیل سے جائزہ لیا اور ان کے ساتھ کام کرنے کی عام مثالوں کو دیکھا۔ لیکن اس ڈیٹا ڈھانچے کے کئی نقصانات ہیں۔ جاوا میں ان کا جواب ArrayList کی ظاہری شکل تھی۔ اسے جتنا آسان ہو سکے، جاوا میں ایک ArrayList بہت ساری نئی خصوصیات کے ساتھ ایک "اپ گریڈ شدہ" صف ہے۔

جاوا اری لسٹ باقاعدہ صفوں سے کیسے مختلف ہے؟

عام طور پر، arrays کافی آسان ہیں اور جیسا کہ آپ نے پہلے ہی دیکھا ہے، آپ ان کے ساتھ بہت سی چیزیں کر سکتے ہیں :) تاہم، arrays کے بھی بہت سے نقصانات ہیں۔

• محدود سائز۔ آپ کو ایک صف بنانے کے مرحلے پر پہلے ہی جاننا ہوگا کہ اس میں کتنے خلیات ہونے چاہئیں۔ اگر آپ مطلوبہ رقم کو کم کرتے ہیں تو کافی جگہ نہیں ہوگی۔ اگر آپ اس کا زیادہ اندازہ لگاتے ہیں تو، صف آدھی خالی رہے گی، اور یہ اتنا برا نہیں ہے۔ سب کے بعد، یہ پتہ چلتا ہے کہ آپ اس کے لئے ضرورت سے زیادہ میموری بھی مختص کریں گے.
• ایک صف میں عناصر کو شامل کرنے کا کوئی طریقہ نہیں ہے۔ آپ کو ہمیشہ واضح طور پر سیل کے انڈیکس کی وضاحت کرنی ہوگی جہاں آپ عنصر شامل کرنا چاہتے ہیں۔ اگر آپ غلطی سے پہلے سے زیر قبضہ سیل کو کچھ مطلوبہ قیمت کے ساتھ بتاتے ہیں، تو اسے اوور رائٹ کر دیا جائے گا۔
• کسی عنصر کو ہٹانے کا کوئی طریقہ نہیں ہے۔ قدر صرف "صفر" کی جا سکتی ہے۔

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

نتیجہ:

[Cat{name='Томас'}, null, Cat{name='Фorпп Маркович'}]

ان تمام کوتاہیوں کو ArrayList کے استعمال سے ختم کیا جا سکتا ہے۔ یہ بہت آسان بنایا گیا ہے:

ArrayList<Cat> cats = new ArrayList<Cat>();

اب ہم نے اشیاء کو ذخیرہ کرنے کے لیے ایک فہرست بنائی ہے Cat۔ توجہ فرمایے:ہم ArrayList کے سائز کی وضاحت نہیں کرتے کیونکہ یہ خود بخود قابل توسیع ہے۔ یہ کیسے ممکن ہے؟ آسانی سے۔ آپ حیران ہوں گے، لیکن ArrayList ایک عام صف پر مبنی ہے :) جی ہاں، اس کے اندر ایک صف ہے جس میں ہمارے عناصر محفوظ ہیں۔ لیکن ArrayList میں اس کے ساتھ کام کرنے کا ایک خاص طریقہ کار ہے:

• جب یہ اندرونی صف بھر جاتی ہے، تو ArrayList اپنے اندر ایک نئی صف بناتی ہے۔ اس کا سائز = (پرانی صف کا سائز * 1.5) +1۔
• تمام ڈیٹا کو پرانی صف سے نئے میں کاپی کیا جاتا ہے۔
• پرانی صف کو کچرا جمع کرنے والے نے ہٹا دیا ہے۔

اس طریقہ کار کی بدولت، ایک ArrayList (ایک صف کے برعکس) ایک نئے عنصر کو شامل کرنے کے لیے ایک طریقہ نافذ کرتی ہے۔ یہ ایک طریقہ ہے add()۔

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Hippopotamus"));
}

نیا عنصر فہرست کے آخر میں شامل کیا جاتا ہے۔ اب زیادہ بہاؤ کا کوئی خطرہ نہیں ہے، لہذا یہ طریقہ کار مکمل طور پر محفوظ ہے. ویسے، ArrayList نہ صرف انڈیکس کے ذریعے کسی آبجیکٹ کو تلاش کر سکتا ہے، بلکہ اس کے برعکس بھی - یہ ArrayList میں آبجیکٹ کے حوالے سے کسی چیز کا انڈیکس تلاش کر سکتا ہے! ایسا کرنے کے لیے، یہ طریقہ نافذ کرتا ہے indexOf(): ہم اس میں مطلوبہ شے کا لنک دیتے ہیں، اور indexOf()یہ اپنا انڈیکس ہمیں واپس کر دیتا ہے:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

نتیجہ:

0

یہ ٹھیک ہے، آبجیکٹ thomasدراصل سیل میں محفوظ ہے 0۔ صفوں کے نہ صرف نقصانات ہیں، بلکہ بلا شبہ فوائد بھی ہیں۔ ان میں سے ایک انڈیکس کے ذریعہ ایک عنصر کی تلاش کر رہا ہے۔ چونکہ ہم ایک انڈیکس کی طرف اشارہ کرتے ہیں، یعنی میموری میں ایک مخصوص ایڈریس کی طرف، اس طرح کی صف کی تلاش بہت تیز ہوتی ہے۔ جاوا میں ArrayList یہ بھی کر سکتی ہے! ایسا کرنے کے لیے، یہ ایک طریقہ نافذ کرتا ہے get():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

نتیجہ:

Cat{name='Бегемот'}

اس کے علاوہ، آپ آسانی سے یہ جان سکتے ہیں کہ آیا ایک ArrayList میں کوئی خاص چیز شامل ہے یا نہیں۔ یہ طریقہ استعمال کرتے ہوئے کیا جاتا ہے contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}

طریقہ چیک کرتا ہے کہ آیا عنصر ArrayList کی اندرونی صف میں موجود ہے، اور نتیجہ کو فارم میں لوٹاتا ہے boolean- trueیا false۔ نتیجہ:

false

اور اندراج کے بارے میں ایک اور اہم بات۔ ArrayList آپ کو نہ صرف صف کے آخر میں، بلکہ کسی بھی سیل میں انڈیکس کے لحاظ سے ڈیٹا داخل کرنے کی اجازت دیتی ہے۔ اس کے لیے دو طریقے ہیں:

• add(int index, Cat element)
• set(int index, Cat element)

دونوں کے لیے، آپ اس سیل کا انڈیکس پاس کرتے ہیں جس میں آپ داخل کرنا چاہتے ہیں، اور خود آبجیکٹ کا لنک۔ فرق یہ ہے کہ پیسٹ کرنے سے set()سیل میں ذخیرہ شدہ پرانی ویلیو اوور رائٹ ہو جاتی ہے۔ اور پہلے داخل کرنے سے صف کے آخر add()سے شروع ہونے والے تمام عناصر کو شفٹ کر دیا جاتا ہے [index]، اور اس چیز کو جو آپ کو مطلوبہ خالی سیل میں شامل کر دیتا ہے۔ یہاں ایک مثال ہے:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Now we have a list of 2 cats. We add the 3rd via set:

   System.out.println(cats.toString());
}

نتیجہ:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Бегемот'}]

ہمارے پاس 2 بلیوں کی فہرست تھی، ہم نے طریقہ کار کے ذریعے ایک اور کو set()سیل میں داخل کیا 0۔ نتیجے کے طور پر، اس سیل میں ذخیرہ شدہ پرانی قدر کو ایک نئی سے تبدیل کر دیا گیا۔

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Now we have a list of 2 cats. Add the 3rd via add

   System.out.println(cats.toString());
}

لیکن اس نے add()مختلف طریقے سے کام کیا۔ اس نے تمام عناصر کو دائیں طرف منتقل کیا اور پھر سیل میں نئی ​​قدر لکھی 0۔ نتیجہ:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]

فہرست کو مکمل طور پر صاف کرنے کے لیے، طریقہ استعمال کریں clear():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}

نتیجہ:

[]

تمام مواد کو فہرست سے ہٹا دیا گیا ہے۔ ویسے، توجہ دیں: arrays کے برعکس، ArrayList میں toString() طریقہ کو اوور رائیڈ کیا جاتا ہے اور فوری طور پر سٹرنگ فارمیٹ میں فہرست دکھاتا ہے۔ arrays کے معاملے میں، ہمیں اس کے لیے Arrays کلاس کا استعمال کرنا پڑا۔ اور چونکہ ہمیں Arrays یاد ہے: جاوا میں آپ آسانی سے ایک array اور ArrayList کے درمیان "سوئچ" کر سکتے ہیں، یعنی ایک کو دوسرے میں تبدیل کر سکتے ہیں۔ Arrays کلاس کے پاس اس کے لیے ایک طریقہ ہے، Arrays.asList()۔ اس کی مدد سے، ہم سرنی کے مواد کو فہرست کے طور پر حاصل کرتے ہیں اور اسے اپنی ArrayList کے کنسٹرکٹر کو بھیج دیتے ہیں:

public static void main(String[] args) {

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

نتیجہ:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Фorпп Маркович'}, Cat{name='Пушок'}]

آپ اس کے برعکس کر سکتے ہیں - ArrayList آبجیکٹ سے ایک صف حاصل کریں۔ ایسا کرنے کے لیے، toArray() طریقہ استعمال کریں:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

براہ کرم نوٹ کریں: ہم نے toArray() طریقہ میں ایک خالی صف بھیجی ہے۔ یہ کوئی غلطی نہیں ہے۔ ArrayList کلاس کے اندر، یہ طریقہ اس طرح لاگو کیا جاتا ہے کہ خالی صف کو گزرنے سے اس کی کارکردگی بڑھ جاتی ہے۔ ابھی کے لیے، اسے مستقبل کے لیے یاد رکھیں (لیکن آپ ایک مخصوص سائز کو بھی منتقل کر سکتے ہیں، یہ کام کرے گا)۔ سائز کی بات کرتے ہوئے۔ فہرست کا موجودہ سائز طریقہ استعمال کرتے ہوئے پایا جا سکتا ہے size():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

یہاں یہ سمجھنا ضروری ہے کہ، lengtharray پراپرٹی کے برعکس، ArrayList.size() طریقہ بالکل عناصر کی تعداد لوٹاتا ہے، نہ کہ ابتدائی صلاحیت، کیونکہ ہم ArrayList بناتے وقت اس کی وضاحت نہیں کرتے ہیں۔ ویسے، عام طور پر اس کی نشاندہی کرنا ممکن ہے۔ ArrayList میں ایک متعلقہ کنسٹرکٹر ہے۔ لیکن نئے عناصر کو شامل کرنے کے معاملے میں اس کا طرز عمل تبدیل نہیں ہوگا:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);//create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

کنسول آؤٹ پٹ:

4

ہم نے 2 عناصر کے ساتھ ایک فہرست بنائی، لیکن جب ہمیں اس کی ضرورت پڑی، تو یہ آسانی سے پھیل گئی۔ ایک اور بات یہ ہے کہ اگر ہم نے ابتدائی طور پر ایک بہت چھوٹی فہرست بنائی ہے، تو اسے زیادہ کثرت سے توسیعی عمل کو انجام دینا پڑے گا، اور اس میں وسائل کی ایک خاص مقدار خرچ ہوتی ہے۔ اس لیکچر میں، ہم نے بمشکل ایک ArrayList سے عناصر کو ہٹانے کے عمل کو چھوا ہے۔ یقیناً یہ بھول جانے کی وجہ سے نہیں ہے۔ اس موضوع کو ایک الگ لیکچر میں الگ کر دیا گیا ہے، جسے آپ مزید پڑھ سکتے ہیں :)