Java ArrayList

سلام پوئين سبقن ۾، اسان صفن ۾ گہرا غوطا ڏنا ۽ صفن سان ڪم ڪرڻ جي عام مثالن جو جائزو ورتو. هن سبق ۾، اسان جاوا ArrayList تي ويجھو جائزو وٺنداسين. عام طور تي، صفون سپر آسان آهن. ۽، جيئن توهان اڳ ۾ ئي محسوس ڪيو آهي، توهان انهن سان گهڻو ڪجهه ڪري سگهو ٿا :) پر 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("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'}] خوشقسمتيءَ سان، جاوا جا ٺاھيندڙ صفن جي فائدن ۽ نقصانن کان چڱيءَ طرح واقف آھن، ۽ تنھنڪري جاوا ArrayList نالي ھڪ تمام دلچسپ ڊيٽا ڍانچي ٺاھيو ويو . جيترو ممڪن ٿي سگهي ڳالهائڻ، هڪ جاوا ArrayList هڪ "سوپ اپ" صف آهي ڪيترن ئي نئين خاصيتن سان.

هڪ ArrayList ڪيئن ٺاهيو

اهو ٺاهڻ لاء تمام آسان آهي:

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

هاڻي اسان هڪ فهرست ٺاهي آهي ٻلي جي شين کي محفوظ ڪرڻ لاءِ. نوٽ ڪريو ته اسان ArrayList جي سائيز جي وضاحت نه ڪري رهيا آهيون ، ڇاڪاڻ ته اهو خودڪار طور تي وڌائي سگھي ٿو. اهو ڪيئن ممڪن آهي؟ اهو بلڪل سادو آهي، اصل ۾. اھو توھان کي حيران ڪري سگھي ٿو، پر جاوا ۾ ArrayList ھڪڙي عام صف جي چوٽي تي ٺهيل آھي :) ھائو، اھو ھڪڙو صف تي مشتمل آھي، ۽ اھو آھي جتي اسان جا عنصر ذخيرو ٿيل آھن. پر جاوا ۾ ArrayList هڪ خاص طريقو آهي انهي صف سان ڪم ڪرڻ جو:

• جڏهن اندروني صف ڀريو ويندو آهي، ArrayList اندروني طور تي نئين صف ٺاهي ٿي. نئين سر جي سائيز پراڻي صف جي ڀيٽ ۾ 1.5 پلس 1 جي ماپ آهي.


• سڀ ڊيٽا پراڻي صف مان نقل ڪئي وئي آهي نئين ۾


• پراڻي صف کي گندي ڪليڪٽر طرفان صاف ڪيو ويندو آهي.

هي ميکانيزم Java ArrayList کي اجازت ڏئي ٿو (هڪ عام صف جي برعڪس) نئين عناصر کي شامل ڪرڻ لاء هڪ طريقو لاڳو ڪرڻ لاء. اهو add()طريقو آهي

public static void main(String[] args) {

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

نئين شيون لسٽ جي آخر ۾ شامل ڪيا ويا آھن. ھاڻي ڪو به خطرو نه آھي صف کي ختم ڪرڻ، تنھنڪري ھي طريقو مڪمل طور تي محفوظ آھي. رستي جي ذريعي، ArrayList نه رڳو ان جي انڊيڪس ذريعي هڪ اعتراض ڳولي سگهي ٿو، پر ان جي برعڪس: اهو ArrayList ۾ هڪ اعتراض جي انڊيڪس ڳولڻ لاء هڪ حوالو استعمال ڪري سگهي ٿو ! اھو اھو آھي جيڪو indexOf() طريقو آھي ان لاءِ: اسان ھڪڙو حوالو پاس ڪريون ٿا جيڪو اسان چاهيون ٿا، ۽ indexOf() ان جي انڊيڪس موٽائي ٿو:

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);

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

ٻاھر نڪتو: 0 اھو صحيح آھي. اسان جو ٿامس اعتراض حقيقت ۾ عنصر 0 ۾ ذخيرو ٿيل آهي. Arrays ۾ صرف خرابيون نه آهن. انهن وٽ پڻ اڻڄاتل فائدا آهن. انهن مان هڪ آهي انڊيڪس ذريعي عناصر کي ڳولڻ جي صلاحيت. ڇاڪاڻ ته اسان هڪ انڊيڪس ڏانهن اشارو ڪندا آهيون، يعني هڪ مخصوص ميموري ايڊريس ڏانهن، هن طريقي سان هڪ صف ڳولڻ تمام جلدي آهي. ArrayListڄاڻي ٿو اهو ڪيئن ڪجي، پڻ! get () طريقو ھن کي لاڳو ڪري ٿو:

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);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

ٻاھر نڪتو: Cat{name='Behemoth'} اضافي طور تي، توھان آساني سان ڳولي سگھوٿا ته ڇا ArrayList ۾ ڪا خاص شئي آھي. ھي ArrayList contains() طريقي سان ڪيو ويندو آھي:

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);

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

طريقو چيڪ ڪري ٿو ته ڇا ArrayList جي اندروني صف ۾ عنصر شامل آهي، ۽ هڪ بوليان (سچو يا غلط) واپس ڪري ٿو. ٻاھر نڪتو: غلط ۽ داخل ڪرڻ بابت ٻي اهم شيء. ArrayList توهان کي انڊيڪس استعمال ڪرڻ جي اجازت ڏئي ٿي عناصر داخل ڪرڻ لاءِ نه رڳو صف جي آخر ۾، پر ڪٿي به. ان لاءِ ٻه طريقا آهن:

• ArrayList add(int index, Cat element)
• ArrayList سيٽ (int index، Cat element)

دليلن جي طور تي، انهن ٻنهي طريقن کي پوزيشن جي انڊيڪس وٺي ٿو جتي توهان داخل ڪرڻ چاهيو ٿا، ۽ پاڻ کي اعتراض جو حوالو. فرق اهو آهي ته سيٽ () استعمال ڪندي داخل ڪرڻ پراڻي قدر کي مٿي ڪري ٿو. add() استعمال ڪندي داخل ڪرڻ سان پھرين ھڪڙي سڀني عنصرن کي [index] کان صف جي آخر تائين شفٽ ڪري ٿو، ۽ پوءِ ڏنل اعتراض کي نتيجي ۾ خالي پوزيشن ۾ شامل ڪري ٿو.

هتي هڪ مثال آهي:

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);

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

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

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

ٻاھر نڪتو: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] اسان وٽ 2 ٻلين جي فهرست ھئي . ان کان پوء اسان هڪ ٻيو داخل ڪيو عنصر 0 طور سيٽ () طريقو استعمال ڪندي. نتيجي طور، پراڻي عنصر هڪ نئين سان تبديل ڪيو ويو آهي.

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);

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

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

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

۽ هتي اسان ڏسون ٿا ته add() مختلف ڪم ڪري ٿو. اهو سڀني عنصرن کي ساڄي طرف منتقل ڪري ٿو ۽ پوءِ نئين قيمت کي عنصر 0 طور لکي ٿو. آئوٽ پٽ: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] فهرست کي مڪمل طور تي صاف ڪرڻ لاءِ، اسان صاف () طريقو استعمال ڪريون ٿا:

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);

   cats.clear();

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

ٻاھر نڪتو: [] سڀڪنھن شيء کي لسٽ مان هٽايو ويو. رستي ۾، مهرباني ڪري نوٽ ڪريو: arrays جي برعڪس، ArrayList toString() طريقي کي ختم ڪري ٿو ۽ اڳ ۾ ئي فهرست کي مناسب طور تي strings طور ڏيکاري ٿو. عام arrays سان، اسان کي ان لاءِ Arrays ڪلاس استعمال ڪرڻو پوندو . ۽ جيئن ته مون ذڪر ڪيو آهي Arrays : Java توهان کي آساني سان هڪ صف ۽ هڪ ArrayList جي وچ ۾ "سوئچ" ڪرڻ جي اجازت ڏئي ٿي ، يعني هڪ کي ٻئي ۾ تبديل ڪريو. Arrays ڪلاس وٽ ھڪڙو Arrays.asList() طريقو آھي ھن لاءِ. اسان ان کي استعمال ڪريون ٿا مواد حاصل ڪرڻ لاءِ هڪ صف جي طور تي ۽ انهن کي اسان جي ArrayList تعمير ڪندڙ ڏانهن منتقل ڪريو:

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");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

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

ٻاھر نڪتو: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] توھان پڻ مخالف طرف ڏانھن وڃو: حاصل ڪريو ArrayList اعتراض مان هڪ صف . اسان هن کي استعمال ڪريون ٿا toArray() طريقو:

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);

   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("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.size());
}

اهو سمجهڻ ضروري آهي ته هڪ صف جي ڊگھائي ملڪيت جي برعڪس، 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("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.size());
}

ڪنسول آئوٽ: 4 اسان 2 عناصر جي هڪ فهرست ٺاهي آهي، پر اهو خاموشيء سان وڌايو ويو جڏهن اسان کي ضرورت هئي. ٻيو خيال اهو آهي ته جيڪڏهن اسان شروعات ۾ هڪ تمام ننڍڙي لسٽ ٺاهيندا آهيون، ان کي گهڻو ڪري وڌائڻو پوندو، جيڪو ڪجهه وسيلن کي استعمال ڪندو. اسان هن سبق ۾ هڪ ArrayList مان عناصر کي هٽائڻ جي عمل کي مشڪل سان ڇڪيو آهي ، يقينا، اهو نه آهي ڇاڪاڻ ته اهو اسان جي دماغ کي ڦٽو ڪيو. اسان هن موضوع کي هڪ الڳ سبق ۾ رکيو آهي جيڪو توهان بعد ۾ ملندا :) جيڪو توهان سکيو آهي ان کي مضبوط ڪرڻ لاءِ، اسان توهان کي اسان جي جاوا ڪورس مان هڪ وڊيو سبق ڏسڻ جي صلاح ڏيو ٿا.