ArrayList sinfining batafsil tahlili [1-qism]

Ushbu maqolada Collections Framework-dan ArrayList sinfi batafsil ko'rib chiqiladi, bu oddiy massivga asoslanganligi sababli tushunish eng osondir. Suhbatda sizga ushbu sinf va uning Java-da qo'llanilishi haqida deyarli savol beriladi. Ikkinchi qismda biz qolgan usullarni tahlil qilamiz va raqamlar uchun dinamik massivni o'zimiz amalga oshirishni yozamiz. ArrayList klassi AbstractList sinfidan meros oladi va quyidagi interfeyslarni amalga oshiradi: List, RandomAccess, Cloneable, Serializable. ArrayList sinfining batafsil tahlili [2-qism] ArrayList klassi kerak bo'lganda kengaytirilishi mumkin bo'lgan dinamik massivlarni qo'llab-quvvatlaydi. Uning zaruriyati va samaradorligi muntazam massivning belgilangan uzunlikka ega bo‘lishi bilan izohlanadi: u yaratilgandan keyin u o‘smaydi yoki kichraymaydi, bu esa massiv qanchalik katta bo‘lishi noma’lum bo‘lsa, cheklovlar qo‘yadi. Aslini olganda, ArrayList klassi ob'ekt havolalarining o'zgaruvchan uzunlikdagi ro'yxat massividir. Ichki massivning o'lchami (hujayralar soni) undan elementlar olib tashlanganida avtomatik ravishda kamaymasligini tushunish muhimdir. sizeHaqiqatan ham, massivda mavjud bo'lgan elementlar sonini ko'rsatadigan o'zgaruvchining qiymati kamayadi. Aytaylik, ArrayList sinfining yangi obyektini yaratamiz va unga 5 ta element qo‘shamiz. Odatiy bo'lib, 10 ta elementdan iborat massiv yaratiladi. Bunday holda, bizning ob'ektimizning sig'imi (hajmi/hajmi) 10 ga teng bo'ladi, lekin o'zgaruvchining qiymati sizebeshga teng bo'ladi. Elementlarni o'chirib tashlaganimizda, biz o'zgaruvchining qiymatidagi o'zgarishlarni ko'ramiz size, chunki biz .lengthArrayList sinfining ichki massiviga kira olmaymiz va uning uzunligini aniqlay olmaymiz. Hajmi qo'shimcha usul yordamida kamaytirilishi mumkin trimToSize(), bu quyida muhokama qilinadi. Keling, sinf maydonlarini ko'rib chiqaylik.

• Dinamik massivning standart hajmi uchun mas'ul bo'lgan maydon:

  private static final int DEFAULT_CAPACITY = 10

  Yangi ob'ektni yaratishda new ArrayList<>() (parametrsiz konstruktor) ichida 10 ta elementdan iborat massiv yaratiladi.

• To'plamning barcha elementlari saqlanadigan maydon:

  transient Object[] elementData

  Kalit so'z bilan belgilangan transient- standart ketma-ketlashtirish algoritmidan foydalanganda maydon bayt oqimiga yozilmaydi. Shuni ta'kidlash kerakki, maydon kalit so'zi bilan belgilanmagan private, ammo bu ichki o'rnatilgan sinflardan (masalan, SubList) ushbu maydonga kirishni osonlashtirish uchun qilingan.

• Massivdagi elementlar sonini saqlaydigan hisoblagich maydoni:

  private int size

  Qo'shish va o'chirish kabi amallarni bajarishda qiymat oshiriladi/kamaytiriladi.

Sinfda yana 3 ta maydon bor, lekin ular mohiyatan qo'shimcha, shuning uchun ularni ko'rib chiqishning ma'nosi yo'q. Sinfda uchta konstruktor mavjud:

1. public ArrayList()– 10 ta elementdan iborat boʻsh roʻyxat massivini yaratadi;
2. public ArrayList(Collection < ? extends E > c)– o‘tkazilgan to‘plam elementlari bilan ishga tushirilgan ro‘yxat massivini yaratadi (agar biz ba’zi to‘plamlar asosida yangi ArrayList yaratmoqchi bo‘lsak);
3. public ArrayList(int initialCapacity)– boshlang‘ich sig‘imga ega ro‘yxat massivini yaratadi. Agar o'tkazilgan initialCapacity parametri 0 dan katta bo'lsa, u holda ko'rsatilgan o'lchamdagi massiv yaratiladi (elementData ichki maydoniga initialCapacity o'lchamidagi Object tipidagi yangi massivga havola tayinlanadi). Agar parametr 0 bo'lsa, bo'sh massiv yaratiladi. Belgilangan parametr 0 dan kichik bo'lsa, u holda IllegalArgumentException tashlanadi.

Ob'ekt yaratish

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

Yangi yaratilgan ob'ektda listxususiyatlar (maydonlar) elementDatava size. Qiymat ombori elementDatama'lum bir turdagi massivdan boshqa narsa emas (umumiy ko'rsatilgan - <>), bizning holatlarimizda String[]. Agar parametrsiz konstruktor chaqirilsa, sukut bo'yicha Object tipidagi 10 ta elementdan iborat massiv yaratiladi (albatta, turga ko'chirish bilan). Elementlarni qo'shish Ro'yxat massiviga klassik tarzda elementlar qo'shish ning haddan tashqari yuklangan variantlari yordamida amalga oshiriladi add().

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

Xo'sh, keling, qo'shamiz: list.add("0"); Ushbu usul ichida usulning haddan tashqari yuklangan versiyasi add()chaqiriladi, deb belgilanadi privateva u o'z navbatida uchta parametrni kiritish sifatida oladi: qo'shiladigan element, ichki massiv va uning o'lchami. Shaxsiy usulda tekshirish sodir bo'ladi: agar o'tkazilgan o'lcham parametri ichki massiv uzunligiga teng bo'lsa (ya'ni massiv to'la bo'lsa), u holda massivga usulning natijasi ( grow(int minCapacity)maydonning joriy qiymati) tayinlanadi. Size + 1 usuliga o'tkaziladi, chunki qo'shilayotgan elementni hisobga olish kerak), bunda ichki massivga asl massivning elementlarini nusxalash orqali olingan yangi yaratilgan massivga havola beriladi:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Usulning ikkinchi parametri sifatida copyOfbiz usulning natijasini ko'rsatamiz newCapacity(int minCapacity), uning ichida yangi massiv hajmi hisoblanadi. U quyidagi formula bo'yicha hisoblanadi: int newCapacity = oldCapacity + (oldCapacity >> 1) Standart o'lchamli massiv uchun quyidagilar to'g'ri bo'ladi: >> 1– bit bo'yicha o'ngga bittaga siljish (sonni yarmigacha qisqartiruvchi operator). Aslida, bu 2 ni 1 ning kuchiga bo'lish degan ma'noni anglatadi. Ma'lum bo'lishicha, biz 10 ni 2 ga bo'lib, 10 qo'shamiz. Hammasi bo'lib, massivning yangi sig'imi 15 ga teng, lekin biz 11-elementni qo'shayotganimiz uchun 15 + 1 bo'ladi. = 16. Keling, ro'yxatimizga qaytaylik va biz unga allaqachon 10 ta element qo'shdik va 11 ta elementni qo'shishga harakat qilaylik. Arrays.copyOfShunga ko'ra, ichki tizim usulidan foydalanadigan yangi massiv yaratiladi va chaqiriladi System.arraycopy(). Yoki JavaRush-dagi bitta maqoladan aniq misol: Bularning barchasi tekshirilgandan so'ng va kerak bo'lganda massiv hajmini oshiring, keyin xususiy usulda add()massiv oxiriga yangi element qo'shiladi va joriy parametr sizebittaga oshiriladi. . Eski massiv keyinchalik axlat yig'uvchi tomonidan qayta ishlanadi. Dinamik massiv shunday ishlaydi: biz elementlarni qo'shganda, unda hali ham joy bor yoki yo'qligini tekshiramiz. Agar bo'sh joy bo'lsa, biz elementni massivning oxiriga qo'shamiz. Oxiri massivdagi oxirgi katakni emas, balki qiymatga mos keladigan katakchani bildiradi size. Biz massivga birinchi elementni qo'shdik, u [0] indeksli katakka joylashtiriladi. Maydon qiymati sizebittaga oshdi va = 1. Keyingi elementni qo'shamiz: biz shuni ko'ramiz size = 1, mos ravishda elementni indeksli katakchaga joylashtiramiz [1] va hokazo. Usulning ikkita parametrli haddan tashqari yuklangan versiyasi mavjud:

public void add(int index, E element)

Biz elementni qo'shmoqchi bo'lgan katakning o'rnini (indeksini) belgilashimiz mumkin. Birinchidan, ko'rsatilgan indeks qiymatining to'g'riligi tekshiriladi, chunki noto'g'ri indeks ko'rsatilishi ehtimoli bor, u hech narsa yo'q yoki oddiygina mavjud bo'lmagan hujayrani ko'rsatadi. Indekslarni tekshirish: index > size || index < 0- agar ko'rsatilgan indeks massivning joriy hajmidan katta bo'lsa yoki u 0 dan kichik bo'lsa, istisno chiqariladi IndexOutOfBoundsException. Keyin, agar kerak bo'lsa, yuqoridagi misolga o'xshash massivning o'lchami oshiriladi. Massivda qo'shish/o'chirish operatsiyalari paytida biror narsa biron joyga (o'ngga yoki chapga) siljishi haqida eshitgan bo'lsangiz kerak. Shunday qilib, siljish massivni nusxalash orqali amalga oshiriladi: System.arraycopy(elementData, index, elementData, index + 1, s - index); Belgilangan indeksning o'ng tomonida joylashgan barcha elementlar o'ngga bir pozitsiyaga siljiydi (indeks+1). Va shundan keyingina ko'rsatilgan indeksdagi ichki massivga yangi element qo'shiladi. Massivning bir qismini o‘ngga bittadan siljitganimiz uchun (yangi massiv yaratilmagan), bizga kerakli katak yozish uchun bepul bo‘ladi. Eski massivga havola o'chiriladi va kelajakda u axlat yig'uvchi tomonidan qabul qilinadi. "Maserati" ni allaqachon band bo'lgan [3] katakka joylashtiring: Shunday qilib, indeksga element kiritilganda va massivda bo'sh joylar bo'lmasa, qo'ng'iroq System.arraycopy()ikki marta amalga oshiriladi: birinchisi ichida grow(), ikkinchisi usulning o'zida add(index, value), bu butun qo'shish operatsiyasining tezligiga aniq ta'sir qiladi. Natijada, ichki massivga boshqa element yozish kerak bo'lganda, lekin u erda bo'sh joy bo'lmasa, ArrayList ichida shunday bo'ladi:

• Yangi massiv originalidan 1,5 baravar kattaroq hajmda va bitta element bilan yaratiladi.
• Eski massivning barcha elementlari yangi massivga ko'chiriladi
• Yangi massiv ArrayList ob'ektining ichki o'zgaruvchisida saqlanadi va eski massiv axlat deb e'lon qilinadi.

ArrayList tipidagi ob'ektlarning sig'imi quyidagi usul yordamida qo'lda oshirilishi mumkin:

public void ensureCapacity(int minCapacity)

Massiv hajmini oldindan oshirib, keyinchalik RAMning qo'shimcha qayta taqsimlanishidan qochishingiz mumkin. Usul ga uzatiladigan elementlar sonini moslashtirish uchun ichki massiv hajmini oshiradi minCapacity. Usul ensureCapacity()maydonga ta'sir qilmaydi size, u capacityichki massivning (o'lchamiga) ta'sir qiladi. Yana bir bor ta'kidlaymanki, sizeikkalasi ham capacityhar xil narsalar va ularni chalkashtirmaslik juda muhim! Agar ArrayList tuzilgan asosiy massiv hajmini amalda saqlangan elementlarning joriy soniga kamaytirishni istasangiz, trimToSize(). To'plamdan elementlarni olib tashlaganingizdan so'ng, size()u aslida mavjud elementlarning sonini ko'rsatadi va capacitykamaymaydi! Aytaylik: biz 100 ta elementni kiritdik, birinchi 50 tasini o'chirib tashladik, sizeu 50 ga teng bo'ladi va shuning uchun capacityu 100 bo'lib qoladi. Kamaytirish uchun va , biz butun imkoniyatlarimizni joriy hajmga moslashtiradigan capacityusuldan foydalanishimiz kerak . trimToSize()Qanday qilib mos keladi? Bo'sh katakchalar qolmasligi uchun massivimizni nusxalaydi (yangi massivning uzunligi shunchaki o'lcham maydoniga teng). dan foydalanib kollektsiyamizga elementlar qo'shishingiz mumkin addAll.

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

Birinchi variant usul parametrida ko'rsatilgan to'plamning barcha elementlarini (masalan, boshqa varaq) usul chaqiruvi amalga oshirilgan asl to'plamga (oxiriga qo'shish) qo'shish imkonini beradi. O'tkazilgan to'plam (u to'plam bo'lishi ham mumkin) yordamida massivga aylantiriladi toArray(). Tabiiyki, qo'shish operatsiyasi nusxalash yordamida ham amalga oshiriladi. Ikkinchisi, collectionindex dan boshlab barcha elementlarni ro'yxatga qo'shishdir index. Bunday holda, barcha elementlar ro'yxatdagi elementlar soni bo'yicha o'ngga siljiydi collection. Elementlarni olib tashlash Birinchidan, ArrayList dan elementlarni olib tashlashning klassik variantlarini ko'rib chiqaylik.

public E remove(int index)

Indeks bo'yicha o'chirishni amalga oshiradi va barcha keyingi elementlarni (belgilangan indeksdagi elementdan keyin) chapga siljitadi va shu bilan "teshiklarni" yopadi. Bundan tashqari, u o'chirishdan oldin qo'shimcha o'zgaruvchiga yozilgan o'chirilgan elementni (E) qaytaradi, uning qiymati biz usul chaqiruvi natijasida olinadi. E nima ekanligini tushunish uchun siz umumiy deb ataladigan turlar bilan tanishishingiz kerak bo'ladi. E belgisi, usul ArrayList ob'ektini yaratishda ko'rsatilgan ma'lumotlar turini qaytarishini bildiradi (esda tuting: List <String> list, mos ravishda, bu holda E "almashtiriladi" String). Umumiy tushunish uchun men sizga umumiy turlar bilan tanishishingizni tavsiya qilaman. Kiritilgan indeksning to'g'riligi tekshiriladi, so'ngra usul ichida element to'liq o'chirilmaydi, lekin shaxsiy usul chaqiriladi fastRemove(Object[] es, int i), unda o'chirish allaqachon sodir bo'ladi. Biz massivimizni va belgilangan indeksni kirish sifatida metodga o'tkazamiz. Elementlar yordamida nusxa ko'chiriladi System.arraycopy(), massivning o'lchami kichraytiriladi va keyin biz oxirgi elementga null belgilaymiz. Shuni ta'kidlash kerakki, yangi massiv yaratilmaydi: System.arraycopy(es, i + 1, es, i, size - 1 - i); Belgilangan indeks (i+1) ostidagi pozitsiyaning o'ng tomonidagi qism bizning asl massivimizga (es) ko'chiriladi va u o'sha joydan boshlab joylashgan. (i) o'chirilishi kerak bo'lgan element joylashgan joy. Shunday qilib, biz chapga siljishni amalga oshirdik va elementimizni o'chirib tashladik. Keling, 3-indeksdagi elementni quyidagi qatordan olib tashlashga harakat qilaylik: Keling, usulning ikkinchi versiyasini ko'rib chiqaylik:

public boolean remove(Object o)

Usul o'tgan elementni ro'yxatdan o, aniqrog'i, belgilangan havoladagi ob'ektni olib tashlaydi. Ro'yxatda biror element mavjud bo'lsa, u o'chiriladi va barcha elementlar chapga siljiydi. Agar element ro'yxatda mavjud bo'lsa va muvaffaqiyatli o'chirilgan bo'lsa, usul "true" ni qaytaradi, aks holda "false". Indeks bo'yicha o'chirish variantiga o'xshash usul deyiladi fastRemove(), bu erda aynan bir xil harakatlar sodir bo'ladi. Farqi shundaki, usul qo'shimcha ravishda Object sinfining remove(Object o)usuli orqali kerakli ob'ektni qidiradi . equals()Qiymat bo'yicha olib tashlashda, moslik topilmaguncha, tsikl ro'yxatning barcha elementlaridan o'tadi. Faqat birinchi topilgan element o'chiriladi. Xulosa qilib olaylik: dinamik massivdan elementlarni o‘chirishda oddiy massivdagi kabi teshiklar qolmaydi (o‘chirilgan katak bo‘sh bo‘lmaydi). Barcha keyingi elementlar (indeksning o'ng tomonida joylashgan) bir pozitsiya chapga siljiydi. Ro'yxatdagi elementlarni turli darajada olib tashlash uchun bir nechta qo'shimcha usullar mavjud. Keling, ularni qisqacha ko'rib chiqaylik. To'plamimizni tozalash:

public void clear()

Oddiy tsikl formassivning barcha elementlarini takrorlaydi va har bir elementga null qiymatini beradi. Siz boshqa uzatilgan to'plamda mavjud bo'lgan elementlarni bizning kollektsiyamizdan olib tashlashingiz mumkin:

public boolean removeAll(Collection< ?> c)

Agar siz bir nechta elementlarni olib tashlashingiz kerak bo'lsa, ehtimol buni shartli tsiklda qilmasligingiz kerak: usuldan foydalanish qulayroq va xavfsizroq removeAll(). U ro'yxatdan olib tashlanadigan elementlar to'plamini qabul qiladi. To'plam maqsadli ro'yxat saqlaydigan bir xil turdagi elementlarni o'z ichiga olishi kerak. Aks holda u tashlanadi ClassCastException. Ro'yxat usul chaqiruvi natijasida o'zgartirilgan bo'lsa, usul rostni qaytaradi. O'tkazilgan to'plamga tegishli bo'lmagan elementlarni olib tashlaydi:

public boolean retainAll(Collection< ?> c)

Aytaylik, bizda to'plam bor:

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

Va ikkinchisi:

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

Keyin listSecond.retainAll(listFirst)indan keyin listSecondqoladi:

"White"
"Red"

"Yashil" o'chirilganligi sababli, bu listFirst. Ammo listSecond.removeAll(listFirst)bundan keyin ham listSecondqoladi:

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

O'tgan to'plamga tegishli emas - agar o'tgan to'plamda bo'lmagan elementlar mavjud bo'lsa, ularni birinchisidan (usul qo'llaniladigan) olib tashlashingiz kerakligini anglatadi. O'tkazilgan kollektsiyaga tegishli - shunga ko'ra, agar birinchi va ikkinchi (ko'chirilgan) to'plamlarda element mavjud bo'lsa, unda birinchisidan dublikat yo'q qilinadi.

protected void removeRange(int fromIndex, int toIndex)

Belgilangan boshlang'ich indeks (shu jumladan) va oxirgi ko'rsatilgan indeks (shu jumladan emas) o'rtasidagi barcha elementlarni ro'yxatdan olib tashlaydi. Shuni ta'kidlash kerakki, usulni to'g'ridan-to'g'ri ArrayList ob'ektida chaqirib bo'lmaydi. Uni ishlatish uchun siz meros qilib olishingiz kerak AbstractList/ArrayList. Usul boshqa usul bilan ham qo'llaniladi (subList, keyinroq muhokama qilinadi).

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

Berilgan predikat asosida to'plamdan elementlarni olib tashlaydi. Predikatning o'zi ma'lum bir funktsiya/algoritm/shart bo'lib, uning asosida berilgan shartga mos keladigan bir yoki bir nechta elementlar o'chiriladi. Predicate— funktsional interfeys (faqat bitta usulni o'z ichiga oladi, shuning uchun uni lambda sifatida ishlatish mumkin), "bitta parametr olingan - mantiqiy qaytarilgan" tamoyili bo'yicha ishlaydi. Asosan, usul interfeysdan amalga oshirishni bekor qiladi Collectionva quyidagi "strategiya" ni amalga oshiradi: u elementlar orasidan o'tadi va bizning Predicate; keyin birinchi iteratsiyada belgilangan elementlarni olib tashlash (va o'zgartirish) uchun ikkinchi marta bajariladi. PredicateKeling , ikkita ob'ekt teng bo'lsa, haqiqatni qaytaradigan interfeysni amalga oshiramiz :

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

StringBoshqa sinfda ArrayList ni va sinfimizning ob'ektini yaratamiz, u quyidagilarni amalga oshiradi Predicate:

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

O'zgaruvchiga varc1"White" qiymatini yozamiz:

filter.varc1 = "White";

Keling, ro'yxatga bir nechta qatorlarni qo'shamiz:

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

Ro'yxatdagi usulni bajaramiz removeIf, unga ob'ektimizni shart bilan o'tkazamiz:

color_list.removeIf(filter);

Natijada, "Oq" qiymatiga ega bo'lgan barcha qatorlar ro'yxatdan o'chiriladi, chunki bizning "predikatimiz" ularni tenglik uchun taqqoslaydi. Yakuniy ro'yxat: [Qora, Qizil, Sariq]. Elementlarni almashtirish

public E set(int index, E element)

Belgilangan joydagi elementni indexo'tgan bilan almashtiradi element. Indeks ham noldan katta va oxirgi element indeksidan kichik bo'lishi kerak, aks holda istisno chiqariladi IndexOutOfBoundsException. Ichki massivning nusxalari paydo bo'lmaydi. Oddiy qilib aytganda, ko'rsatilgan indeksdagi element o'rniga yangi element qo'shiladi, ya'ni. qiymatning ustiga yozing.

public void replaceAll(UnaryOperator<e> operator)

To'plamning barcha elementlarini o'zgartiradi (shart bilan mumkin). Ko'pincha lambdalar yoki anonim sinf bilan birgalikda ishlatiladi (lekin aniqlik uchun misolda biz interfeysni amalga oshiradigan sinfdan foydalanamiz) interfeysni amalga oshiradigan UnaryOperatorva uning usullarini belgilaydi. Keling, interfeysni amalga oshiramiz:

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

StringBoshqa sinfda ArrayList ni va sinfimizning ob'ektini yaratamiz, u quyidagilarni amalga oshiradi UnaryOperator:

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

O'zgaruvchiga varc1"White" qiymatini yozamiz:

operator.varc1 = "White";

Keling, ro'yxatga bir nechta qatorlarni qo'shamiz:

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

replaceAllKeling , ob'ektimizni o'tkazadigan ro'yxatdagi usulni bajaramiz operator:

color_list.replaceAll(operator);

Natijada, ro'yxatdagi barcha qiymatlar "Oq" bilan almashtirildi: [Oq, Oq, Oq, Oq, Oq, Oq]. Masalan, siz to'plamdagi satrlardan barcha bo'shliqlarni shunday olib tashlashingiz mumkin:

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

Boshqa usullar: ArrayList roʻyxati massivini quyidagi usul yordamida oddiy massivga aylantirishingiz mumkin:

public Object[] toArray()

yoki

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

- bu erda qaytarilgan massivning turi aniqlanadi runtime Ushbu usul quyidagilarga imkon beradi:

1. ba'zi operatsiyalarni tezlashtirish;
2. to'plamni bevosita qabul qilish uchun ortiqcha yuklanmagan usulga parametr sifatida massivni o'tkazish;
3. To‘plamga asoslangan yangi kodni to‘plamlarni tanimaydigan eski kod bilan integratsiyalash.

Massivning nusxa ko'chirish ob'ektini qaytaring:

public Object clone()

E'tibor bering, usul clone()Ob'ekt turini qaytaradi, shuning uchun uni chaqirgandan so'ng siz kerakli sinfga o'tishingiz kerak bo'ladi. Klonlash yangi mustaqil ob'ektni yaratadi. To'plamni ob'ekt mavjudligini tekshiring:

public boolean contains(Object o)

Ro'yxatda ob'ekt mavjudligini tekshiradi (ichki ravishda Object sinfining teng usulidan foydalanish, ya'ni havolalarni solishtiradi), natijaga qarab rost/noto'g'ri qaytaradi. Odatiy tsikllarga qo'shimcha ravishda siz to'plamni takrorlashingiz mumkin (har bir elementga kirish, shuningdek, ba'zi harakatlarni bajarish):

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

Biz ro'yxatimizni shunday ko'rsatishimiz mumkin:

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

Lambdalardan foydalanmasdan siz anonim sinfdan foydalanishingiz va acceptinterfeys usulini bekor qilishingiz kerak Consumer:

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

Indeks bo'yicha elementni oling:

public E get(int index)

To'plam elementlariga tasodifiy kirish uchun foydalaniladi. Belgilangan indeksdagi ro'yxatda joylashgan elementni qaytaradi. Ro'yxatdagi elementlarning maksimal soni index < 0yoki bo'lsa , istisno chiqariladi . Bu roʻyxatdagi elementni olishning asosiy usuli boʻlib, elementni indeks boʻyicha olish vaqti, ArrayList oʻlchamidan qatʼi nazar, har doim bir xil boʻladi, chunki u maʼlum bir massiv yacheykaga kirmoqda. Belgilangan ob'ektlar uchun indekslarni topish: index >=IndexOutOfBoundsException

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

Usullar ro'yxatdagi birinchi (berilgan ob'ekt birinchi marta duch kelganda) yoki oxirgi (berilgan ob'ekt oxirgi marta uchrashganda) elementining indeksini qaytaradi. Agar element ro'yxatda bo'lmasa, usullar -1 ni qaytaradi. To'plamda elementlarni tekshiring:

public boolean isEmpty();

Ro'yxat bo'sh bo'lsa (maydon teng yoki yo'qligini tekshiradi size 0) rost, aks holda noto'g'ri qiymatini qaytaradi. Agar ro'yxat faqat null elementlardan iborat bo'lsa, usul noto'g'ri qiymatni qaytaradi. Boshqacha aytganda, bu usul bilan null elementlar ham hisobga olinadi. Ro'yxatdagi elementlar sonini aniqlang:

public int size();

Roʻyxatdagi elementlar sonini qaytaradi (oʻlcham maydoni qiymatlari). Elementlar soni ro'yxatdagi sig'imdan (imkoniyatdan) farq qilishi mumkin. Ro'yxat uchun iteratorni oling:

public Iterator< E> iterator();

Loop yoki boshqa qayta ishlashda keyinchalik foydalanish uchun roʻyxat uchun iteratorni qaytaradi. Iterator muvaffaqiyatsiz tezkor xatti-harakatni amalga oshiradi. Agar u to'plamdan o'tib ketsa va unga ba'zi o'zgartirishlar kiritilsa (iterator usullari yordamida olinmagan), u darhol istisno qiladi ConcurrentModificationException. Iterator deb nomlangan narsaga ega modification count. Iterator har biridan keyin to'plamni takrorlaganda next/hasNext/remove, bu hisoblagichni tekshiradi. Agar iterator ko'rishni kutgan narsaga mos kelmasa, u istisno qiladi. Bu erda iteratorlarni batafsil ko'rib chiqmayman.

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

Loop yoki boshqa qayta ishlashda keyinroq foydalanish uchun roʻyxat iteratorini qaytaradi. Interfeys ro'yxatni ikki tomonlama o'tish va uning elementlarini o'zgartirish uchun ListIteratorinterfeysni kengaytiradi . IteratorHaddan tashqari yuklangan versiyada siz "o'tish" boshlanadigan indeksdan o'tishingiz mumkin. Bu holda indeks usul o'z ishini boshlaydigan birinchi elementni bildiradi next()va usul chaqirilganda, previous()o'tish "o'tgan indeks - 1" indeksi ostidagi elementdan boshlanadi.

public Spliterator <E> spliterator()

Java 8 ajratuvchi iterator deb ataladigan kech bog'lanish va muvaffaqiyatsiz tez iteratorning yangi turini taqdim etadi. Separator iteratorlari elementlar ketma-ketligini takrorlash imkonini beradi, lekin ular boshqacha tarzda ishlatiladi. Spliterator interfeysining eng muhim xususiyati elementlar ketma-ketligining alohida qismlarining parallel takrorlanishini va shuning uchun parallel dasturlashni qo'llab-quvvatlash qobiliyatidir.