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("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;

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


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

ٻاھر نڪتو: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] پر هڪ صف جي عنصر کي null ڪرڻ سان "سوراخ" نڪري ٿو. اسان صف ۾ پوزيشن کي نه هٽايو آهي، صرف ان جو مواد. تصور ڪريو ته ڇا ٿيندو جيڪڏهن اسان وٽ 50 ٻليون هجن ۽ انهن مان 17 کي هن طريقي سان هٽايو. اسان وٽ 17 سوراخ سان گڏ هڪ صف هوندي. بس انھن جي ٽريڪ رکڻ جي ڪوشش ڪريو! اهو غير حقيقي آهي خالي خاني جي تعداد کي ياد ڪرڻ جي اميد جتي توهان نوان قدر لکي سگهو ٿا. جيڪڏهن توهان هڪ غلطي ڪريو ٿا، توهان هڪ اعتراض جي حوالي سان مٿي لکندا آهيو جيڪو توهان چاهيو ٿا. يقينن، ھڪڙو طريقو آھي اھو ڪجھ وڌيڪ احتياط سان: ھڪڙي عنصر کي ختم ڪرڻ کان پوء، عناصر کي صف جي اڳيان ڏانھن منتقل ڪريو "سوراخ" کي آخر ۾ رکڻ لاء:

public static void main(String[] args) {

   Cat[] cats = new Cat[4];
   cats[0] = new Cat("Thomas");
   cats[1] = new Cat("Behemoth");
   cats[2] = new Cat("Lionel Messi");
   cats[2] = new Cat("Fluffy");

   cats[1] = null;

   for (int i = 2; i < cats.length-1; i++) {
       cats [i-1] = cats [i];// Move the elements to the front of the array, so the empty position is at the end
   }

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

ٻاھر نڪتو: [Cat{name='Thomas'}, Cat{name='Fluffy'}, Cat{name='Fluffy'}, null] اھو بھتر لڳي ٿو، پر اھو مشڪل سان ڪو مضبوط حل چئي سگھجي ٿو. جيڪڏهن حقيقت کان سواءِ ٻيو ڪو به سبب ناهي ته اسان کي اهو ڪوڊ هر وقت لکڻو پوندو جڏهن اسان هڪ عنصر کي صف مان حذف ڪندا آهيون! هي هڪ خراب اختيار آهي. اسان ٻئي طريقي سان وڃو ۽ هڪ الڳ طريقو ٺاهي سگهون ٿا:

public void deleteCat(Cat[] cats, int indexToDelete) {
   //...delete the cat corresponding to the index and move the elements
}

پر اهو پڻ ٿورو استعمال جو آهي: اهو طريقو صرف شين سان ڪم ڪري سگهي ٿو Cat، پر ٻين قسمن سان نه. ٻين لفظن ۾، جيڪڏهن هڪ پروگرام ۾ ٻيون 100 ڪلاس آهن جيڪي اسان arrays سان استعمال ڪرڻ چاهيون ٿا، اسان کي انهن مان هر هڪ ۾ بلڪل ساڳي منطق سان ساڳيو طريقو لکڻو پوندو. هي هڪ مڪمل آفت آهي -_- پر ArrayListطبقو اهو مسئلو حل ڪري ٿو! اهو عناصر کي هٽائڻ لاء هڪ خاص طريقو لاڳو ڪري ٿو:remove()

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);
   System.out.println(cats.toString());

   cats.remove(1);

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

اسان پنهنجي اعتراض جي انڊيڪس کي طريقي سان منتقل ڪريون ٿا، جيڪو ان کي ختم ڪري ٿو (جهڙوڪ هڪ صف ۾). طريقو remove()ٻه خاص خاصيتون آهن. پهرين، اهو "سوراخ" نه ڇڏيندو آهي. اهو اڳ ۾ ئي منطق کي لاڳو ڪري ٿو عناصر کي شفٽ ڪرڻ جي ضرورت آهي جڏهن هڪ عنصر وچ مان هٽايو ويندو آهي، جيڪو اسان اڳ ۾ لکيو آهي. پوئين ڪوڊ مان آئوٽ ڏسو:

[Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]

[Cat{name='Thomas'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}]

اسان ھڪڙي ٻلي کي وچ مان ڪڍي ڇڏيو، ۽ باقي ھليا ويا ته جيئن ڪو به خالي جاء نه ھجي. ٻيو ، اهو شيون ختم ڪري سگهي ٿو نه رڳو انڊيڪس (جهڙوڪ هڪ عام صف)، پر حوالن سان پڻ :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);
   System.out.println(cats.toString());

   cats.remove(lionel);

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

ٻاھر نڪتو: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Fluffy'}] اهو تمام آسان ٿي سگهي ٿو جيڪڏهن توهان نه ٿا چاهيو ته هميشه گهربل شئي جي انڊيڪس جي ٽريڪ رکو. اهو لڳي ٿو ته اسان کي عام حذف ڪرڻ جو اندازو لڳايو آهي. هاڻي اچو ته هن صورتحال کي تصور ڪريون: اسان چاهيون ٿا ته اسان جي فهرست تي ٻيهر ورجائي ۽ هڪ خاص نالي سان هڪ ٻلي کي هٽايو . هن کي ڪرڻ لاءِ، اسان هڪ فاسٽ لوپ استعمال ڪنداسين for(جنهن کي هر هڪ لاءِ لوپ به سڏيو ويندو آهي)، جنهن سان اسان کي رشي جي سبقن ۾ متعارف ڪرايو ويو هو:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

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

   for (Cat cat: cats) {

       if (cat.name.equals("Behemoth")) {
           cats.remove(cat);
       }
   }

   System.out.println(cats);
}

ڪوڊ بلڪل منطقي نظر اچي ٿو. پر نتيجو هڪ وڏو تعجب ٿي سگهي ٿو: سلسلي ۾ استثنا "main" java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) java.util.ArrayList$Itr.next(ArrayList. java:831) Cat.main (Cat.java:25) تي ڪجهه قسم جي غلطي آهي، ۽ اهو واضح ناهي ته اهو ڇو ٿيو. هن عمل ۾ شامل آهن nuances جو هڪ انگ جنهن کي خطاب ڪيو وڃي. هتي عام قاعدو آهي جنهن کي توهان کي ياد رکڻ جي ضرورت آهي: توهان هڪ ئي وقت گڏ نه ٿا ڪري سگهو هڪ مجموعو تي ٻيهر ورجائي ۽ ان جي عناصر کي تبديل ڪريو. ۽ اسان جو مطلب آهي ڪنهن به قسم جي تبديلي، نه رڳو هٽائڻ. جيڪڏهن توهان ٻلي کي هٽائڻ جي بدران نئين ٻليون داخل ڪرڻ جي ڪوشش سان، نتيجو ساڳيو ٿيندو:

for (Cat cat: cats) {

   cats.add(new Cat("Salem Saberhagen"));
}

System.out.println(cats);

"main" سلسلي ۾ استثنا java.util.ConcurrentModificationException at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859) at java.util.ArrayList$Itr.next(ArrayList.java:831 تي Cat. Cat.java:25) اسان هڪ آپريشن کي ٻئي ۾ تبديل ڪيو، پر نتيجو تبديل نه ٿيو: اسان کي ساڳيو ConcurrentModificationException ملي ٿو . اهو خاص طور تي ٿئي ٿو جڏهن اسان مٿي ڏنل قاعدي کي ٽوڙڻ جي ڪوشش ڪريون ٿا لسٽ کي تبديل ڪندي ان تي ٻيهر ورجائيندي. جاوا ۾، اسان کي ھڪڙي خاص شئي جي ضرورت آھي جنھن کي آئٽرٽر (Iteratorڪلاس) سڏيو ويندو آھي شيون ختم ڪرڻ لاءِ جڏھن ھڪڙي مجموعن تي ورجائيندي. ڪلاسIteratorعناصر جي فهرست تي محفوظ طور تي ٻيهر ورجائڻ جو ذميوار آهي. اهو بلڪل سادو آهي، ڇاڪاڻ ته ان ۾ صرف 3 طريقا آهن:

• hasNext()- واپسي صحيح يا غلط، ان تي منحصر ڪري ٿو ته ڇا لسٽ ۾ ايندڙ شيء آھي، يا اسان اڳ ۾ ئي آخري ھڪڙي تي پهچي چڪا آھيون.
• next()- لسٽ ۾ ايندڙ شيون واپس ڏئي ٿو
• remove()- فهرست مان هڪ شيء کي هٽائي ٿو

جئين توهان ڏسي سگهو ٿا، آئيٽرٽر اسان جي ضرورتن لاء ٺهيل آهي، ۽ ساڳئي وقت ان بابت ڪا به پيچيده ناهي. فرض ڪريو ته اسان چيڪ ڪرڻ چاهيون ٿا ته ڇا اسان جي لسٽ ۾ ايندڙ عنصر آهي، ۽ ان کي ڏيکاري جيڪڏهن اتي آهي:

Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list

   Cat nextCat = catIterator.next();// Get the next element
   System.out.println(nextCat);// Display it
}

آئوٽ پٽ: ٻلي{name='Thomas'} Cat{name='Behemoth'} Cat{name='Lionel Messi'} Cat{name='Fluffy'} جيئن توهان ڏسي سگهو ٿا، اڳ ۾ ئي هڪ ٺاهڻ لاءِ هڪ ArrayListخاص طريقو لاڳو ڪيو آهي تکرار ڪندڙ: iterator(). اضافي طور تي، ياد رکو ته جڏهن اسان هڪ آئٽرٽر ٺاهيندا آهيون، اسان شين جي درجي کي بيان ڪريون ٿا ته اهو ڪم ڪندو ( <Cat>). هيٺئين لڪير اهو آهي ته هڪ آئٽرٽر آساني سان اسان جي اصل ڪم کي سنڀاليندو آهي. مثال طور، "Lionel Messi" نالي ٻلي کي هٽايو:

Iterator<Cat> catIterator = cats.iterator();// Create an iterator
while(catIterator.hasNext()) {// As long as there are elements in the list

   Cat nextCat = catIterator.next();// Get the next element
   if (nextCat.name.equals("Lionel Messi")) {
       catIterator.remove();// Delete the cat with the specified name
   }
}

System.out.println(cats);

آئوٽ پٽ: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Fluffy'}] توهان شايد اهو محسوس ڪيو هوندو ته اسان انڊيڪس يا نالو بيان نه ڪيو آهي انڊيڪس يا نالو ٻيهر ڪرڻ واري remove()طريقي ۾ ! آئٽرٽر وڌيڪ هوشيار آهي ان کان وڌيڪ ظاهر ٿي سگھي ٿو: remove()آخري عنصر کي هٽائي ٿو جيڪو آئٽرٽر طرفان واپس آيو آهي. جئين توهان ڏسي سگهو ٿا، اهو صرف اهو ڪيو جيڪو اسان چاهيون ٿا :) اصول ۾، اهو سڀ ڪجهه آهي جيڪو توهان کي ڄاڻڻ جي ضرورت آهي عناصر کي هٽائڻ بابت ArrayList. خير، لڳ ڀڳ هر شيء. ايندڙ سبق ۾، اسين هن ڪلاس جي اندر ڏسنداسين، ۽ ڏسنداسين ته اتي مختلف طريقن جي ڪالن دوران ڇا ٿئي ٿو :) ان وقت تائين!