ArrayList طبقي جو تفصيلي تجزيو [حصو 1]

هي آرٽيڪل ڪليڪشن فريم ورڪ مان ArrayList ڪلاس تي تفصيلي نظر وجهندو، جيڪو شايد سمجھڻ ۾ سڀ کان آسان آهي، ڇاڪاڻ ته اهو هڪ باقاعده صف تي ٻڌل آهي. توهان تقريبن ضرور هن ڪلاس بابت سوال ڪيو ويندو ۽ انٽرويو ۾ جاوا ۾ ان تي عمل درآمد. ٻئي حصي ۾ اسان باقي طريقن جو تجزيو ڪنداسين ۽ انگن لاءِ متحرڪ صف جو پنهنجو عمل لکنداسين. ArrayList ڪلاس AbstractList طبقي مان ورثي ۾ ملي ٿو ۽ ھيٺين انٽرفيس کي لاڳو ڪري ٿو: List, RandomAccess, Cloneable, Serializable. ArrayList ڪلاس جو تفصيلي تجزيو [حصو 2] ArrayList ڪلاس متحرڪ صفن کي سپورٽ ڪري ٿو جيڪي ضرورت جي مطابق وڌائي سگھجن ٿيون. ان جي ضرورت ۽ تاثير ان حقيقت سان بيان ڪئي وئي آهي ته هڪ باقاعده صف جي هڪ مقرر ڊگھائي آهي: هڪ دفعو اهو ٺهيل آهي، اهو نه وڌي سگهي ٿو يا گهٽجي سگهي ٿو، جيڪو پابنديون لاڳو ڪري ٿو جيڪڏهن اهو معلوم ناهي ته صف جي ڪيتري وڏي ضرورت هوندي. لازمي طور تي، ArrayList طبقو اعتراض جي حوالن جي ھڪڙي متغير-لمبائي لسٽ صف آھي. اهو سمجهڻ ضروري آهي ته اندروني صف جي سائيز (سيلز جو تعداد) خودڪار طور تي گهٽ نه ٿيندو جڏهن عناصر ان مان هٽايو وڃي. حقيقت ۾، متغير جو قدر size، جيڪو اشارو ڪري ٿو ته عناصر جو تعداد اصل ۾ صف ۾ موجود آهي، گھٽجي ويو آهي. اچو ته چئو ته اسان ArrayList طبقي جو هڪ نئون اعتراض ٺاهيو ۽ ان ۾ 5 عناصر شامل ڪريو. ڊفالٽ طور، 10 عناصر جي هڪ صف ٺاهي وئي آهي. انهي حالت ۾، اسان جي اعتراض جي نام نهاد گنجائش (سائز/حجم) 10 جي برابر هوندي، پر متغير جي قيمت sizeپنجن جي برابر هوندي. ۽ جڏهن اسان عناصر کي حذف ڪريون ٿا، اسان تبديلين کي ڏسون ٿا variable جي قدر ۾ size، ڇاڪاڻ ته اسان .lengthArrayList طبقي جي اندروني صف تائين رسائي نٿا ڪري سگهون ۽ ان جي ڊيگهه کي ڳولي سگهون ٿا. سائيز کي گھٽائي سگھجي ٿو ھڪڙو اضافي طريقو استعمال ڪندي trimToSize()، جيڪو بعد ۾ بحث ڪيو ويندو. اچو ته ڪلاس جي شعبن کي ڏسو.

• متحرڪ صف جي ڊفالٽ حجم لاءِ ذميوار فيلڊ:

  private static final int DEFAULT_CAPACITY = 10

  جڏهن نئين شئي ٺاهي نئين ArrayList<>() (پيراميٽر کان سواءِ تعمير ڪندڙ)، اندر 10 عناصر جو هڪ صف ٺاهيو ويندو آهي.

• هڪ فيلڊ جنهن ۾ مجموعي جا سڀئي عناصر محفوظ ٿيل آهن:

  transient Object[] elementData

  هڪ لفظ سان نشان لڳل transient- فيلڊ کي بائيٽ اسٽريم ڏانهن نه لکيو ويو آهي جڏهن معياري سيريلائيزيشن الگورتھم استعمال ڪندي. اها ڳالهه نوٽ ڪرڻ جي قابل آهي ته فيلڊ کي ڪي لفظ سان نشان نه لڳايو ويو آهي private، پر اهو ڪيو ويو ته جيئن هن فيلڊ تائين رسائي کي آسان بڻائي سگهجي nested طبقن کان (مثال طور، SubList).

• هڪ ڪائونٽر فيلڊ جيڪو اصل ۾ عناصر جو تعداد ذخيرو ڪري ٿو صف ۾:

  private int size

  قدر وڌايو ويندو آهي / گھٽجي ويندو آهي جڏهن آپريشن انجام ڏيڻ جهڙوڪ داخل ڪرڻ ۽ حذف ڪرڻ.

ڪلاس ۾ 3 وڌيڪ شعبا آهن، پر بنيادي طور تي اهي اضافي آهن، تنهنڪري انهن تي غور ڪرڻ جو ڪو به مقصد ناهي. ڪلاس ۾ ٽي ٺاھيندڙ آھن:

1. public ArrayList()- 10 عناصر جي هڪ خالي لسٽ صف ٺاهي ٿو؛
2. public ArrayList(Collection < ? extends E > c)- ھڪڙي لسٽ ترتيب ٺاھيو آھي شروعاتي ترتيب ڏنل مجموعن مان عناصر سان (جيڪڏھن اسان ڪجھ مجموعن جي بنياد تي ھڪڙو نئون ArrayList بڻائڻ چاھيون ٿا)؛
3. public ArrayList(int initialCapacity)- ھڪڙي شروعاتي گنجائش سان ھڪڙي فهرست لسٽ ٺاھي ٿو. جيڪڏهن منظور ٿيل پيٽرولر شروعاتي ڪيپيسيٽي 0 کان وڌيڪ آهي، ته پوءِ مخصوص سائيز جي هڪ صف ٺاهي ويندي آهي (اندروني فيلڊ عنصر ڊيٽا کي هڪ لنڪ لڳايو ويو آهي هڪ نئين سري جي قسم جي Object of size initialCapacity). جيڪڏهن پيٽرولر 0 آهي، پوء هڪ خالي صف ٺاهي وئي آهي. جيڪڏهن بيان ڪيل پيٽرولر 0 کان گهٽ آهي، ته پوء هڪ غيرقانوني آرگيومينٽ ايڪسپشن اڇلايو ويندو.

شئي ٺاهڻ

List < String> list = new ArrayList<>();

نئين ٺاهيل اعتراض listتي مشتمل آهي خاصيتون (فيلڊز) elementData۽ size. اسان جي صورت ۾ هڪ قيمتي اسٽور elementDataهڪ مخصوص قسم جي هڪ صف کان وڌيڪ ڪجهه نه آهي (عام - ۾ بيان ڪيل <>)، اسان جي صورت ۾ String[]. جيڪڏھن ھڪڙي ٺاھيندڙ کي سڏيو ويندو آھي پيرا ميٽرن کان سواءِ، پوءِ ڊفالٽ طور تي 10 عنصرن جي ھڪڙي ترتيب ٺاھي ويندي قسم جي Object (قيمت سان قسم کي ڪاسٽ ڪرڻ سان). عناصر کي شامل ڪرڻ ڪلاسيڪي طور تي عناصر کي فهرست جي صف ۾ شامل ڪرڻ جي اوور لوڊ ٿيل مختلف قسمن کي استعمال ڪندي ڪيو ويندو آهي add().

public boolean add(E элемент)

خير، اچو ته شامل ڪريون: list.add("0"); هن طريقي جي اندر، طريقي جي هڪ اوورلوڊ ٿيل ورزن کي add()سڏيو ويندو آهي، نشان لڳل آهي private، جنهن جي نتيجي ۾ ان پٽ جي طور تي ٽي پيٽرولر وٺندو آهي: عنصر شامل ڪيو وڃي، اندروني صف ۽ ان جي سائيز. خانگي طريقي ۾، هڪ چيڪ ٿئي ٿو: جيڪڏهن پاس ٿيل سائيز پيٽرولر اندروني صف جي ڊيگهه جي برابر آهي (يعني، صف مڪمل آهي)، پوء سر کي طريقي جي نتيجي ۾ مقرر ڪيو ويو آهي grow(int minCapacity)(فيلڊ جي موجوده قيمت. سائيز + 1 طريقي سان منظور ڪيو ويو آهي، ڇاڪاڻ ته اهو ضروري آهي ته عنصر کي شامل ڪيو وڃي)، جنهن ۾ اندروني صف کي نئين ٺاهيل صف جي لنڪ مقرر ڪئي وئي آهي جيڪا اصل صف جي عناصر کي نقل ڪندي حاصل ڪئي وئي آهي:

Arrays.copyOf(elementData, newCapacity(minCapacity))

طريقي جي ٻئي پيٽرولر جي طور تي، copyOfاسان طريقي جو نتيجو ظاهر ڪريون ٿا newCapacity(int minCapacity)، جنهن جي اندر نئين سري جي سائيز جي حساب سان. اهو هيٺ ڏنل فارمولا استعمال ڪندي ڳڻيو ويندو آهي: int newCapacity = oldCapacity + (oldCapacity >> 1) ڊفالٽ سائيز سان هڪ صف لاءِ، هيٺيون صحيحون ٿينديون: >> 1- ساڄي طرف هڪ طرف bitwise شفٽ ڪريو (هڪ آپريٽر جيڪو هڪ عدد کي اڌ تائين گھٽائي ٿو). لازمي طور تي، ان جو مطلب آھي 2 سان ورهائڻ 1 جي طاقت کي. ان مان معلوم ٿئي ٿو ته اسان 10 کي 2 سان ورهايو ۽ 10 شامل ڪيو. مجموعي طور تي، صف جي نئين گنجائش 15 آھي، پر جڏھن اسين 11 هين عنصر شامل ڪري رھيا آھيون، پوء 15 + 1 = 16. اچو ته اسان جي لسٽ تي واپس وڃو ۽ فرض ڪريو ته اسان اڳ ۾ ئي 10 عناصر شامل ڪيا آھن ۽ 11 شامل ڪرڻ جي ڪوشش ڪريو. چيڪ ڏيکاريندو ته صف ۾ ڪا جاء ناهي. ان جي مطابق، هڪ نئين صف ٺاهي وئي آهي ۽ سڏيو ويندو آهي Arrays.copyOf، جيڪو اندروني طور تي سسٽم جو طريقو استعمال ڪري ٿو System.arraycopy(). يا هتي JavaRush تي هڪ آرٽيڪل مان هڪ واضح مثال آهي: انهن سڀني چيڪن کان پوءِ ۽ جيڪڏهن ضروري هجي ته صف جي سائيز کي وڌايو وڃي، پوءِ هڪ خانگي طريقي سان add()صف جي آخر ۾ هڪ نئون عنصر شامل ڪيو ويندو آهي، ۽ موجوده پيراميٽر sizeهڪ کان وڌايو ويندو آهي. . پراڻي صف کي بعد ۾ ڪچري جي ڪليڪٽر طرفان پروسيس ڪيو ويندو. هي ڪيئن هڪ متحرڪ صف ڪم ڪري ٿو: جڏهن اسان عناصر شامل ڪندا آهيون، اسان چيڪ ڪريون ٿا ته ڇا اڃا ان ۾ گنجائش آهي. جيڪڏهن گنجائش آهي، ته اسان صرف عنصر کي صف جي آخر ۾ شامل ڪندا آهيون. پڇاڙيءَ جو مطلب صف ۾ آخري سيل نه آھي، پر اھو سيل جيڪو قدر سان ملندو آھي size. اسان پهرين عنصر کي صف ۾ شامل ڪيو؛ اهو انڊيڪس [0] سان سيل ۾ رکيل آهي. فيلڊ جي قيمت sizeهڪ کان وڌي وئي آهي ۽ = 1. اسان ايندڙ عنصر شامل ڪريون ٿا: اسان ڏسون ٿا ته size = 1، ان مطابق اسان عنصر کي انڊيڪس [1] وغيره سان سيل ۾ رکون ٿا. طريقو جو ھڪڙو اوورلوڊ ورزن آھي ٻن پيٽرولن سان:

public void add(int index, E element)

اسان سيل جي پوزيشن (انڊيڪس) بيان ڪري سگھون ٿا جتي اسان عنصر شامل ڪرڻ چاهيون ٿا. پهرين، مخصوص انڊيڪس جي قيمت جي درستگي جي جانچ ڪئي وئي آهي، ڇاڪاڻ ته اتي هڪ امڪان آهي ته هڪ غلط انڊيڪس بيان ڪيو ويندو، جيڪو هڪ سيل ڏانهن اشارو ڪندو جتي ڪجھ به ناهي، يا جيڪو صرف موجود ناهي. انڊيڪس چيڪ ڪرڻ: index > size || index < 0- جيڪڏهن مخصوص انڊيڪس صف جي موجوده سائيز کان وڏو آهي يا اهو 0 کان گهٽ آهي، پوء هڪ استثنا اڇلايو ويندو آهي IndexOutOfBoundsException. پوء، جيڪڏهن ضروري هجي ته، صف جي سائيز کي وڌايو وڃي، مٿين مثال وانگر. توهان شايد ٻڌو هوندو ته هڪ صف ۾ شامل ڪرڻ/هٽائڻ واري عمل دوران، ڪا شيءِ ڪنهن هنڌ (يا ساڄي يا کاٻي طرف) منتقل ٿي ويندي آهي. تنهن ڪري، شفٽ صف کي نقل ڪندي ڪيو ويندو آهي: System.arraycopy(elementData, index, elementData, index + 1, s - index); مخصوص انڊيڪس جي ساڄي پاسي واقع سڀئي عناصر هڪ پوزيشن کي ساڄي طرف منتقل ڪيو ويندو (انڊيڪس + 1). ۽ صرف ان کان پوء هڪ نئون عنصر شامل ڪيو ويو آهي اندروني صف ۾ مخصوص انڊيڪس تي. جيئن ته اسان صفن جو حصو هڪ طرف ساڄي طرف منتقل ڪيو آهي (هڪ نئين سري پيدا نه ڪئي وئي آهي)، اسان کي گهربل سيل لکڻ لاء مفت هوندو. پراڻي صف جي لنڪ کي ختم ڪيو ويو آهي ۽ مستقبل ۾ اهو ڪچرو ڪليڪٽر طرفان ورتو ويندو. "maserati" کي سيل ۾ پيسٽ ڪريو [3]، جيڪو اڳ ۾ ئي قبضو ڪيو ويو آهي: اهڙيء طرح، جڏهن هڪ عنصر انڊيڪس تي داخل ڪيو ويندو آهي ۽ صف ۾ ڪابه خالي جاء نه هوندي آهي، ڪال System.arraycopy()ٻه ڀيرا ٿيندي: پهريون ان ۾ grow()، ٻيو طريقو پاڻ ۾ add(index, value)، جيڪو واضح طور تي مڪمل اضافو آپريشن جي رفتار کي متاثر ڪندو. نتيجي طور، جڏهن اهو ضروري آهي ته هڪ ٻيو عنصر اندروني صف ۾ لکڻ لاء، پر اتي ڪا جاء ناهي، پوء اهو ئي آهي جيڪو ArrayList اندر ٿئي ٿو:

• ھڪڙو نئون صف ٺاھيو ويو آھي ھڪڙي سائيز سان 1.5 ڀيرا وڏو اصل ھڪڙي کان، وڌيڪ ھڪڙو عنصر.
• پراڻن صفن مان سڀئي عناصر نئين صف ۾ نقل ڪيا ويا آھن
• نئون صف ArrayList اعتراض جي اندروني متغير ۾ ذخيرو ٿيل آهي، ۽ پراڻي صف کي ردي قرار ڏنو ويو آهي.

ArrayList قسم جي شين جي صلاحيت کي دستي طور تي استعمال ڪندي وڌائي سگھجي ٿو:

public void ensureCapacity(int minCapacity)

اڳ ۾ ئي صف جي گنجائش وڌائڻ سان، توهان بعد ۾ رام جي اضافي ورهاست کان پاسو ڪري سگهو ٿا. اهو طريقو اندروني سرن جي سائيز کي وڌائي ٿو ته انهن عنصرن جي تعداد کي ترتيب ڏيڻ لاءِ minCapacity. طريقو ensureCapacity()فيلڊ تي اثر انداز نٿو ڪري size، اهو اثر انداز ڪري ٿو capacity(جي سائيز) اندروني صف. هڪ دفعو ٻيهر مان زور ڀريان ٿو ته sizeٻئي capacityمختلف شيون آهن ۽ اهو تمام ضروري آهي ته انهن کي پريشان نه ڪرڻ! جيڪڏهن توهان هيٺئين صف جي سائيز کي گهٽائڻ چاهيو ٿا جتان ArrayList اصل ۾ ذخيرو ٿيل عناصر جي موجوده تعداد تي ٺهيل آهي، توهان کي ڪال ڪرڻ گهرجي trimToSize(). مجموعي مان عناصر کي هٽائڻ کان پوء، size()اهو اصل ۾ موجود عناصر جو تعداد ڏيکاريندو، ۽ capacityگهٽ نه ٿيندو! فرض ڪريو: اسان 100 عنصر داخل ڪيا، پهرين 50 کي حذف ڪيو، sizeاهو 50 جي برابر ٿي ويندو، ۽ پوء capacityاهو 100 رهندو. گھٽائڻ ۽ capacity، اسان کي اهو طريقو استعمال ڪرڻو پوندو trimToSize()، جيڪو اسان جي سموري گنجائش کي موجوده سائيز سان ترتيب ڏئي ٿو. اهو ڪيئن ٺهڪي اچي ٿو؟ اسان جي صف کي نقل ڪري ٿو ته جيئن ڪو به خالي خانو رهجي نه وڃي (نئين صف جي ڊيگهه صرف سائيز جي فيلڊ جي برابر آهي). توھان پڻ شامل ڪري سگھو ٿا عناصر اسان جي مجموعي ۾ استعمال ڪندي addAll.

public boolean addAll(Collection< ? extends E> c)
public boolean addAll(int index, Collection< ? extends E> collection);

پهريون اختيار توهان کي اجازت ڏئي ٿو ته سڀني عنصرن کي شامل ڪرڻ جي مجموعي مان بيان ڪيل طريقي جي پيٽرولر ۾ (مثال طور، هڪ ٻيو شيٽ) اصل مجموعي ۾ (آخر ۾ داخل ڪريو) جنهن لاءِ طريقو ڪال ڪيو ويو هو. منظور ٿيل مجموعو (اهو پڻ هڪ سيٽ ٿي سگهي ٿو) استعمال ڪندي هڪ صف ۾ تبديل ڪيو ويو آهي toArray(). قدرتي طور تي، اضافو آپريشن پڻ نقل ڪيو ويندو آهي. ٻيو آهي collectionفهرست ۾ سڀني عناصر کي شامل ڪرڻ، انڊيڪس کان شروع ٿيندڙ index. هن حالت ۾، سڀئي عناصر فهرست ۾ عناصر جي تعداد جي حساب سان ساڄي طرف شفٽ ٿيندا collection. عنصرن کي هٽائڻ پهريون، اچو ته ڏسون ڪلاسڪ آپشنز کي ختم ڪرڻ لاءِ هڪ ArrayList مان عناصر.

public E remove(int index)

انڊيڪس ذريعي حذف ڪرڻ کي انجام ڏئي ٿو ۽ سڀني ايندڙن کي (عنصر کان پوءِ بيان ڪيل انڊيڪس تي) عناصر کي کاٻي پاسي ڦيرائي ٿو، ان ڪري "سوراخ" کي بند ڪري ٿو. اهو حذف ٿيل عنصر (E) کي پڻ واپس ڪري ٿو، جيڪو اڳ ۾ حذف ڪرڻ کان اڳ هڪ اضافي متغير ڏانهن لکيو ويو آهي، جنهن جي قيمت جنهن جي نتيجي ۾ اسان حاصل ڪندا آهيون طريقي جي ڪال جي نتيجي ۾. سمجھڻ لاءِ E ڇا آھي، توھان کي نام نہاد عام قسمن سان واقف ٿيڻو پوندو. نوٽشن E اشارو ڪري ٿو ته طريقو ڊيٽا جي قسم کي واپس ڏئي ٿو جيڪو بيان ڪيو ويو هو جڏهن ArrayList اعتراض ٺاهيو (ياد رکو:، List <String> listمطابق، هن صورت ۾، E کي "متبادل" ڪيو ويندو String). عام سمجھڻ لاءِ، مان زور سان صلاح ڏيان ٿو ته توھان پاڻ کي عام قسمن سان واقف ڪيو. داخل ٿيل انڊيڪس جي درستگي کي چڪاس ڪيو ويو آهي، ۽ پوء طريقي جي اندر، عنصر مڪمل طور تي ختم نه ڪيو ويو آهي، پر هڪ خانگي طريقو سڏيو ويندو آهي fastRemove(Object[] es, int i)، جنهن ۾ ختم ٿيڻ اڳ ۾ ئي ٿئي ٿي. اسان ان پٽ جي طور تي طريقي سان اسان جي صف ۽ مخصوص انڊيڪس پاس ڪريون ٿا. عناصر کي استعمال ڪندي نقل ڪيو ويو آهي System.arraycopy()، صف جي سائيز گھٽجي ويندي آهي، ۽ پوء اسان آخري عنصر کي null تفويض ڪندا آهيون. اها ڳالهه نوٽ ڪرڻ جي قابل آهي ته هڪ نئين صف پيدا نه ڪئي وئي آهي: System.arraycopy(es, i + 1, es, i, size - 1 - i); اهو حصو جيڪو مخصوص انڊيڪس (i+1) هيٺ پوزيشن جي ساڄي پاسي آهي اسان جي اصل صف (es) ۾ نقل ڪيو ويو آهي، ۽ اهو بلڪل پوزيشن کان شروع ٿيندڙ واقع آهي. (i) جتي عنصر موجود هو ختم ڪيو وڃي. ان ڪري، اسان کاٻي طرف شفٽ ڪيو ۽ اسان جي عنصر کي ختم ڪيو. اچو ته انڊيڪس 3 تي عنصر کي هيٺ ڏنل صف مان هٽائڻ جي ڪوشش ڪريون. اچو ته طريقي جي ٻئي نسخي تي غور ڪريو:

public boolean remove(Object o)

اهو طريقو فهرست مان منظور ٿيل عنصر کي هٽائي ٿو o، يا وڌيڪ واضح طور تي، مخصوص لنڪ تي اعتراض. جيڪڏهن هڪ عنصر فهرست ۾ موجود آهي، اهو هٽايو ويو آهي ۽ سڀئي عناصر کاٻي پاسي ڏانهن منتقل ڪيا ويا آهن. جيڪڏهن عنصر فهرست ۾ موجود آهي ۽ ڪاميابيء سان هٽايو ويو آهي، طريقو صحيح آهي؛ ٻي صورت ۾، غلط. انڊيڪس ذريعي حذف ڪرڻ جي اختيار سان ملندڙ، طريقو سڏيو ويندو آهي fastRemove()، جتي بلڪل ساڳيون ڪارناما ٿين ٿا. فرق اهو آهي ته اهو طريقو اضافي طور تي مطلوب اعتراض جي ڳولا ڪري ٿو Object ڪلاس جي remove(Object o)طريقي سان . equals()جڏهن قيمت سان هٽايو وڃي، لوپ لسٽ جي سڀني عنصرن جي ذريعي وڃي ٿو جيستائين هڪ ميچ نه ملي. صرف پهريون عنصر مليو جيڪو ختم ڪيو ويندو. اچو ته اختصار ڪريون: جڏهن متحرڪ صفن مان عناصر کي حذف ڪيو وڃي، اتي ڪو به سوراخ نه بچندو آهي جيئن باقاعده صف ۾ (ڊليٽ ٿيل سيل خالي نه هوندو). سڀ ايندڙ عناصر (جيڪي انڊيڪس جي ساڄي پاسي هئا) هڪ پوزيشن کي کاٻي طرف منتقل ڪيو ويو آهي. اتي ڪيترائي اضافي طريقا آھن جيڪي استعمال ڪري سگھجن ٿيون عناصر کي فهرست مان ختم ڪرڻ لاءِ مختلف درجي تائين. اچو ته انهن کي مختصر طور تي ڏسو. اسان جي مجموعي کي صاف ڪرڻ:

public void clear()

هڪ سادي لوپ forهڪ صف جي سڀني عنصرن جي ذريعي ورجائي ٿو، هر عنصر کي null تفويض ڪري ٿو. توھان انھن عنصرن کي ختم ڪري سگھو ٿا اسان جي مجموعن مان جيڪي ڪنھن ٻئي منتقل ٿيل مجموعن ۾ موجود آھن جھڙوڪ:

public boolean removeAll(Collection< ?> c)

جيڪڏهن توهان کي ڪيترن ئي عناصر کي هٽائڻ جي ضرورت آهي، توهان کي شايد اهو نه ڪرڻ گهرجي مشروط لوپ ۾: اهو طريقو استعمال ڪرڻ وڌيڪ آسان ۽ محفوظ آهي removeAll(). اهو عناصر جو هڪ مجموعو قبول ڪري ٿو جيڪو فهرست مان هٽايو ويندو. مجموعي ۾ لازمي طور تي ساڳئي قسم جا عنصر شامل آهن جيڪي ٽارگيٽ لسٽ اسٽور ڪري ٿو. ٻي صورت ۾ اهو اڇلايو ويندو ClassCastException. اهو طريقو درست ٿي ويندو جيڪڏهن لسٽ تبديل ڪئي وئي طريقي جي ڪال جي نتيجي ۾. عناصر کي هٽائي ٿو جيڪي منظور ٿيل مجموعن سان تعلق نه رکن ٿا:

public boolean retainAll(Collection< ?> c)

اچو ته اسان وٽ هڪ مجموعو آهي:

List< String> listFirst = new ArrayList<>();
listFirst.add("White");
listFirst.add("Black");
listFirst.add("Red");

۽ ٻيو:

List< String> listSecond = new ArrayList<>();
listSecond.add("Green");
listSecond.add("Red");
listSecond.add("White");

ان کان پوءِ listSecond.retainAll(listFirst)اندر listSecondرهندو:

"White"
"Red"

جتان "گرين" کي هٽايو ويو، جيڪو نه آهي listFirst. پر listSecond.removeAll(listFirst)ان کان پوء اهو listSecondرهندو:

"Green"
Удалorсь все элементы, которые есть в listFirst.

منظور ٿيل مجموعن سان واسطو نه آهي - مطلب ته جيڪڏهن اهڙا عنصر آهن جيڪي منظور ٿيل مجموعن ۾ نه آهن، پوء توهان کي انهن کي پهرين کان هٽائڻ جي ضرورت آهي (جنهن جو طريقو لاڳو ٿئي ٿو). منتقل ٿيل مجموعن سان تعلق رکي ٿو - مطابق، جيڪڏهن پهريون ۽ ٻيو (منتقل ٿيل) مجموعن ۾ هڪ عنصر موجود آهي، ته پوء پهريون کان نقل تباهه ٿي ويندو.

protected void removeRange(int fromIndex, int toIndex)

فهرست مان هٽائي ٿو سڀئي عنصر جيڪي شروع ٿيندڙ مخصوص انڊيڪس (شامل) ۽ ختم ٿيندڙ مخصوص انڊيڪس (شامل نه آهن) جي وچ ۾ آهن. اهو قابل ذڪر آهي ته اهو طريقو سڌو سنئون ArrayList اعتراض تي نه ٿو سڏيو وڃي. ان کي استعمال ڪرڻ لاءِ توھان کي وراثت حاصل ڪرڻ جي ضرورت آھي AbstractList/ArrayList. اهو طريقو پڻ استعمال ڪيو ويندو آهي هڪ ٻيو طريقو (ذيلي لسٽ، جنهن تي بعد ۾ بحث ڪيو ويندو).

public boolean removeIf(Predicate< ? super E> filter)

ھڪڙي ڏنل پيشڪش جي بنياد تي ھڪڙي مجموعي مان عناصر کي ختم ڪري ٿو. اڳڪٿي پاڻ هڪ خاص فنڪشن/الگورٿم/حالت آهي جنهن جي بنياد تي هڪ يا وڌيڪ عنصرن کي هٽايو ويندو جيڪو ڏنل شرط سان ملندو. Predicate- هڪ فنڪشنل انٽرفيس (صرف هڪ طريقو تي مشتمل آهي، تنهنڪري اهو هڪ ليمبڊا طور استعمال ڪري سگهجي ٿو)، اصول تي ڪم ڪري ٿو "وصول هڪ پيٽرولر - واپسي بولين". لازمي طور تي، طريقو انٽرفيس مان عمل درآمد کي ختم ڪري ٿو Collection۽ هيٺ ڏنل "حڪمت" کي لاڳو ڪري ٿو: اهو عناصر جي ذريعي ڦري ٿو ۽ انهن کي نشانو بڻائي ٿو جيڪي اسان سان ملن ٿا Predicate؛ ان کان پوءِ ان عنصرن کي هٽائڻ (۽ شفٽ) ڪرڻ لاءِ ٻئي دفعي هلايو ويندو آهي جيڪي پهرين ورهاڱي ۾ نشان لڳل هئا. اچو ته هڪ انٽرفيس کي لاڳو ڪريو Predicateجيڪو صحيح موٽندو جيڪڏهن ٻه شيون برابر آهن:

class SamplePredicate< T> implements Predicate< T>{
  T varc1;
  public boolean test(T varc){
     if(varc1.equals(varc)){
       return true;
  }
  return false;
  }
}

ٻئي ڪلاس ۾، اچو ته هڪ ArrayList مان ٺاهيون String۽ اسان جي ڪلاس جو هڪ اعتراض جيڪو لاڳو ڪري ٿو Predicate:

ArrayList< String> color_list = new ArrayList<> ();
SamplePredicate< String> filter = new SamplePredicate<> ();

varc1اچو ته لکون "اڇو" قدر کي متغير ڏانهن :

filter.varc1 = "White";

اچو ته لسٽ ۾ چند لائين شامل ڪريو:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

اچو ته لسٽ تي طريقي سان عمل ڪريون removeIf، جنهن ۾ اسان شرط سان پنهنجو اعتراض پاس ڪنداسين:

color_list.removeIf(filter);

نتيجي طور، "اڇو" قدر سان سڀئي قطار لسٽ مان ڪڍيا ويندا، ڇو ته اسان جو "predicate" انھن کي برابري لاءِ موازنہ ڪري ٿو. آخري فهرست: [ڪارو، ڳاڙهو، پيلو]. عناصر کي تبديل ڪرڻ

public E set(int index, E element)

عنصر کي مخصوص پوزيشن تي تبديل ڪري ٿو indexمنظور ٿيل سان element. انڊيڪس پڻ صفر کان وڏو ۽ آخري عنصر جي انڊيڪس کان گھٽ هجڻ گھرجي، ٻي صورت ۾ ھڪڙو استثنا اڇلايو ويندو IndexOutOfBoundsException. اندروني صفن جي ڪا به ڪاپي نه ٿي اچي. بس، مخصوص انڊيڪس تي عنصر جي بدران، هڪ نئون عنصر داخل ڪيو ويو آهي، يعني. قدر کي ختم ڪريو.

public void replaceAll(UnaryOperator<e> operator)

مجموعي جي سڀني عناصر کي تبديل ڪري ٿو (ممڪن شرط سان). گهڻو ڪري lambdas يا هڪ گمنام طبقي سان ميلاپ ۾ استعمال ڪيو ويو آهي (پر وضاحت لاءِ، مثال طور اسان صرف هڪ ڪلاس استعمال ڪنداسين جيڪو انٽرفيس کي لاڳو ڪري ٿو) جيڪو انٽرفيس کي لاڳو ڪري ٿو UnaryOperator۽ ان جي طريقن کي بيان ڪري ٿو. اچو ته انٽرفيس کي لاڳو ڪريو:

class MyOperator< T> implements UnaryOperator< T>{
   T varc1;
   public T apply(T varc){
     return varc1;
  }
}

ٻئي ڪلاس ۾، اچو ته هڪ ArrayList مان ٺاهيون String۽ اسان جي ڪلاس جو هڪ اعتراض جيڪو لاڳو ڪري ٿو UnaryOperator:

ArrayList< String> color_list = new ArrayList<> ();
MyOperator< String> operator = new MyOperator<> ();

varc1اچو ته لکون "اڇو" قدر کي متغير ڏانهن :

operator.varc1 = "White";

اچو ته لسٽ ۾ چند لائين شامل ڪريو:

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

اچو ته لسٽ تي ھڪڙو طريقو ٺاھيو replaceAllجنھن ڏانھن اسان پنھنجي اعتراض کي منتقل ڪنداسين operator:

color_list.replaceAll(operator);

نتيجي طور، فهرست ۾ سڀئي قدر "اڇا" سان تبديل ڪيا ويا: [اڇو، اڇو، اڇو، اڇو، اڇو، اڇو]. ۽ اهو ڪيئن آهي، مثال طور، توهان سڀني خالن کي هٽائي سگهو ٿا تارن مان جيڪي جمع ۾ آهن:

ArrayList< String> list = new ArrayList<>(Arrays.asList("A   ", "  B  ", "C"));
list.replaceAll(String::trim);

ٻيا طريقا: توھان استعمال ڪري سگھوٿا ArrayList لسٽ صف کي باقاعده صف ۾ استعمال ڪندي:

public Object[] toArray()

يا

public < T> T[] toArray(T[] a)

- هتي واپس ڪيل صف جو قسم طئي ڪيو ويو آهي runtime هن طريقي جي اجازت ڏيندو:

1. ڪجهه عملن کي تيز ڪرڻ؛
2. ھڪڙي صف کي ھڪڙي نموني جي طور تي ھڪڙي طريقي سان منتقل ڪريو جنھن کي سڌو سنئون قبول ڪرڻ لاء اوورلوڊ ٿيل نه آھي؛
3. نئون مجموعو-بنياد ڪوڊ کي ضم ڪرڻ سان گڏ ميراثي ڪوڊ جيڪو مجموعن جي سڃاڻپ نٿو ڪري.

صف جي ڪاپي اعتراض واپس ڪريو:

public Object clone()

مهرباني ڪري نوٽ ڪريو ته طريقو clone()اعتراض جي قسم کي واپس ڏئي ٿو، تنهنڪري ان کي ڪال ڪرڻ کان پوء توهان کي گهربل ڪلاس ڏانهن ڪاسٽ ڪرڻ جي ضرورت پوندي. ڪلوننگ هڪ نئون آزاد اعتراض ٺاهي ٿو. اعتراض جي موجودگي لاء جمع چيڪ ڪريو:

public boolean contains(Object o)

لسٽ ۾ ھڪڙي اعتراض جي موجودگي جي چڪاس ڪريو (اندروني طور تي اعتراض طبقي جي برابري طريقي کي استعمال ڪندي، يعني حوالن جي مقابلي ۾)، نتيجو جي لحاظ سان سچ / غلط موٽائي ٿو. عام لوپ جي اضافي ۾، توهان استعمال ڪري سگھو ٿا (هر عنصر تائين رسائي، ۽ گڏوگڏ ڪجهه عمل انجام ڏيو) هڪ مجموعو استعمال ڪندي:

public void forEach(Consumer< ? super E> action)

ھي آھي اسان پنھنجي لسٽ کي ڪيئن ڏيکاري سگھون ٿا:

List< Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 50, 100, -5));
numbers.forEach((number)-> System.out.println(number));

ليمبڊاس استعمال ڪرڻ کان سواءِ توهان کي هڪ گمنام ڪلاس استعمال ڪرڻ جي ضرورت آهي ۽ acceptانٽرفيس جو طريقو ختم ڪرڻ جي ضرورت آهي Consumer:

numbers.forEach(new Consumer< Integer>() {
  @Override
   public void accept(Integer integer) {
      System.out.println(integer);
          }
});

انڊيڪس ذريعي هڪ عنصر حاصل ڪريو:

public E get(int index)

گڏ ڪرڻ جي عناصر تائين بي ترتيب رسائي لاء استعمال ڪيو ويو. بيان ڪيل انڊيڪس تي لسٽ ۾ موجود عنصر کي واپس ڏئي ٿو. جيڪڏهن فهرست ۾ عناصر جو وڌ ۾ وڌ تعداد index < 0يا آهي ، هڪ استثنا اڇلايو ويندو . هي فهرست مان هڪ عنصر کي ٻيهر حاصل ڪرڻ جو بنيادي طريقو آهي، ۽ انڊيڪس ذريعي هڪ عنصر کي ٻيهر حاصل ڪرڻ جو وقت هميشه ساڳيو هوندو، قطع نظر ArrayList جي سائيز جي، ڇاڪاڻ ته اهو هڪ مخصوص صف سيل تائين رسائي ڪري رهيو آهي. مخصوص شيون لاء انڊيڪس ڳولڻ: index >=IndexOutOfBoundsException

public int indexOf(Object o);
public int lastIndexOf(Object o);

طريقن جي فهرست ۾ پهريون (جڏهن ڏنل اعتراض پهريون ڀيرو سامهون آيو آهي) يا آخري واقعا (جڏهن ڏنل اعتراض آخري ڀيرو سامهون آيو آهي) عنصر جي فهرست کي واپس ڪري ٿو. جيڪڏهن عنصر فهرست ۾ موجود نه آهي، طريقا موٽندا -1. عناصر لاء جمع چيڪ ڪريو:

public boolean isEmpty();

اهو طريقو صحيح موٽندو آهي جيڪڏهن فهرست خالي آهي (ڏسجي ته فيلڊ برابر آهي size 0)، ٻي صورت ۾ غلط. جيڪڏهن فهرست ۾ صرف null عناصر شامل آهن، طريقو غلط ٿيندو. ٻين لفظن ۾، null عناصر به هن طريقي سان حساب ۾ ورتو وڃي ٿو. ھڪڙي فهرست ۾ عناصر جو تعداد ڳولھيو:

public int size();

لسٽ ۾ عناصر جو تعداد واپس ڪري ٿو (سائيز فيلڊ ويلز). عناصر جو تعداد فهرست جي گنجائش (ظرفيت) کان مختلف ٿي سگھي ٿو. هڪ فهرست لاءِ هڪ آئٽرٽر حاصل ڪريو:

public Iterator< E> iterator();

لوپ يا ڪنهن ٻئي پروسيسنگ ۾ بعد ۾ استعمال لاءِ لسٽ لاءِ هڪ آئٽرٽر واپسي. آئيٽرٽر ناڪام-تيز رويي کي لاڳو ڪري ٿو. جيڪڏهن اهو گڏ ڪرڻ جي ذريعي هلندو آهي ۽ ان ۾ ڪجهه ترميمن کي نوٽيس ڪري ٿو (جيڪي آئيٽرٽر طريقن کي استعمال ڪندي حاصل نه ڪيا ويا هئا)، اهو فوري طور تي هڪ استثنا اڇلائي ٿو ConcurrentModificationException. ريٽٽر کي ڪجهه سڏيو ويندو آهي modification count. جڏهن هر هڪ کان پوء گڏ ڪرڻ جي ذريعي ٻيهر ورجائي ٿو next/hasNext/remove، اهو هن انسداد کي چيڪ ڪري ٿو. جيڪڏهن اهو ملندو نه آهي جيڪو ٻيهر ڏسڻ جي اميد رکي ٿو، اهو هڪ استثنا اڇلائي ٿو. مان هتي تفصيل سان تکرار ڪندڙن تي غور نه ڪندس.

public ListIterator< E> listIterator() и public ListIterator< E> listIterator(int index)

لوپ يا ڪنهن ٻئي پروسيسنگ ۾ بعد ۾ استعمال لاءِ لسٽ لاءِ هڪ فهرست ٻيهر ورجائي ٿو. انٽرفيس ListIteratorانٽرفيس کي وڌائي ٿو Iteratorٻن طرفن جي ٽرورسل لسٽ ۽ ان جي عناصرن جي ترميم لاءِ. اوورلوڊ ٿيل ورزن ۾، توھان انڊيڪس پاس ڪري سگھو ٿا جتان "ٽرورسل" شروع ٿيندو. هن معاملي ۾ انڊيڪس پهرين عنصر کي ظاهر ڪري ٿو جنهن مان طريقو پنهنجو ڪم شروع ڪندو next()، ۽ جڏهن طريقو سڏيو ويندو آهي، previous()انڊيڪس "پاس ٿيل انڊيڪس - 1" جي هيٺان عنصر کان ٽرورسل شروع ٿيندي.

public Spliterator <E> spliterator()

جاوا 8 هڪ نئين قسم جو ليٽ بائنڊنگ ۽ ناڪام فاسٽ آئٽرٽر متعارف ڪرايو جنهن کي ڊيليميٽر آئٽرٽر سڏيو ويندو آهي. جدا ڪندڙ آئٽرٽر توهان کي اجازت ڏين ٿا ته عناصر جي هڪ ترتيب تي ٻيهر ورجائي، پر اهي مختلف طريقي سان استعمال ڪيا ويا آهن. Spliterator انٽرفيس جي سڀ کان اهم خصوصيت ان جي عناصر جي تسلسل جي انفرادي حصن جي متوازي ورهاڱي کي سپورٽ ڪرڻ جي صلاحيت آهي، ۽ تنهن ڪري متوازي پروگرامنگ.