جاوا ۾ ArrayList ڪلاس

سلام! پوئين ليڪچرن ۾، اسان تفصيل سان جانچيو ته اهڙي ڊيٽا جي جوڙجڪ هڪ صف جي طور تي ۽ انهن سان ڪم ڪرڻ جي عام مثالن کي ڏٺو. پر هن ڊيٽا جي جوڙجڪ ۾ ڪيترائي نقصان آهن. جاوا ۾ انهن جو جواب ArrayList جي ظاهري هئي. ان کي آسان طور تي رکڻ لاءِ، جاوا ۾ هڪ ArrayList ڪيترن ئي نئين خاصيتن سان گڏ ”اپ گريڊ ٿيل“ صف آهي.

جاوا Arraylist باقاعده صفن کان ڪيئن مختلف آهي؟

عام طور تي، صفون ڪافي آسان آهن ۽، جيئن توهان اڳ ۾ ئي محسوس ڪيو آهي، توهان انهن سان تمام گهڻو ڪم ڪري سگهو ٿا :) جڏهن ته، صفن ۾ پڻ ڪيترائي نقصان آهن.

• محدود سائيز. توهان کي اڳ ۾ ئي ڄاڻڻ جي ضرورت آهي ته هڪ صف ٺاهڻ جي اسٽيج تي ان ۾ ڪيترا سيلز هجڻ گهرجن. جيڪڏهن توهان گهربل رقم کي گهٽايو، اتي ڪافي جاء نه هوندي. جيڪڏهن توهان ان کي وڌايو، صف اڌ خالي رهندي، ۽ اهو ايترو خراب ناهي. آخرڪار، اهو ظاهر ٿئي ٿو ته توهان ان لاء ضروري کان وڌيڪ ياداشت پڻ مختص ڪنداسين.
• هڪ صف ۾ عناصر شامل ڪرڻ جو ڪو طريقو ناهي. توهان کي هميشه واضح طور تي سيل جي انڊيڪس کي بيان ڪرڻو پوندو جتي توهان عنصر شامل ڪرڻ چاهيو ٿا. جيڪڏهن توهان غلطيءَ سان اڳ ۾ ئي قبضو ڪيل سيل کي ڪجهه گهربل قيمت سان بيان ڪيو، اهو اوور رائٽ ڪيو ويندو.
• هڪ عنصر کي هٽائڻ لاء ڪي به طريقا نه آهن. قيمت صرف "صفر" ٿي سگهي ٿو.

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. Arrays ۾ نه رڳو نقصان آهن، پر ان ۾ شڪ نه ٿيڻ جا فائدا پڻ آهن. انهن مان هڪ عنصر ڳولي رهيو آهي انڊيڪس ذريعي. جيئن ته اسان هڪ انڊيڪس ڏانهن اشارو ڪيو آهي، يعني ميموري ۾ هڪ مخصوص ايڊريس ڏانهن، اهڙي قسم جي ڳولا تمام تيز آهي. جاوا ۾ 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 کي ياد ڪيو: جاوا ۾ توهان آساني سان هڪ صف ۽ هڪ 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 مان عناصر کي هٽائڻ جي عمل تي رابطو ڪيو. يقينا، اهو وسارڻ جو سبب ناهي. هن موضوع کي هڪ الڳ ليڪچر ۾ ورهايو ويو آهي، جنهن کي توهان اڳتي پڙهي سگهو ٿا :)