Analisis rinci kelas ArrayList [Bagian 1]

Artikel iki bakal nliti rinci babagan kelas ArrayList saka Framework Koleksi, sing bisa uga paling gampang dingerteni, amarga adhedhasar array biasa. Sampeyan meh mesthi bakal dijaluk pitakonan babagan kelas iki lan implementasine ing basa Jawa nalika wawancara. Ing bagean kapindho kita bakal njelasno cara isih lan nulis implementasine dhewe saka array dinamis kanggo nomer. Kelas ArrayList warisan saka kelas AbstractList lan ngleksanakake antarmuka ing ngisor iki: List, RandomAccess, Cloneable, Serializable. Analisis rinci saka kelas ArrayList [Part 2] Kelas ArrayList ndhukung array dinamis sing bisa ditambahi yen perlu. Keperluan lan efektifitas kasebut diterangake kanthi kasunyatan manawa array reguler duwe dawa tetep: yen digawe, ora bisa tuwuh utawa nyusut, sing ndadekake watesan yen ora diweruhi sepira gedhene array sing dibutuhake. Ateges, kelas ArrayList minangka array dhaptar variabel referensi obyek. Penting kanggo mangerteni yen ukuran (jumlah sel) saka array internal ora otomatis suda nalika unsur dibusak saka iku. Nyatane, nilai variabel size, sing nuduhake jumlah unsur sing ana ing array, wis suda. Ayo kita nggawe obyek anyar saka kelas ArrayList lan nambah 5 unsur. Kanthi gawan, array 10 unsur digawe. Ing kasus iki, kapasitas sing diarani (ukuran / volume) obyek kita bakal padha karo 10, nanging nilai variabel sizebakal padha karo lima. Lan nalika kita mbusak unsur, kita ndeleng owah-owahan ing Nilai saka variabel size, awit kita .lengthora bisa ngakses Uploaded internal saka kelas ArrayList lan mangerteni dawa. Ukuran bisa dikurangi kanthi nggunakake metode tambahan trimToSize(), sing bakal dibahas ing ngisor iki. Ayo ndeleng lapangan kelas.

• Bidang sing tanggung jawab kanggo volume standar array dinamis:

  private static final int DEFAULT_CAPACITY = 10

  Nalika nggawe obyek anyar ArrayList anyar<>() (konstruktor tanpa paramèter), Uploaded 10 unsur digawe nang.

• Lapangan ing ngendi kabeh unsur koleksi disimpen:

  transient Object[] elementData

  Ditandhani karo tembung kunci transient- kolom ora ditulis ing stream byte nalika nggunakake algoritma serialization standar. Wigati dicathet yen kolom kasebut ora ditandhani karo tembung kunci private, nanging iki ditindakake supaya bisa nggampangake akses menyang lapangan iki saka kelas bersarang (contone, SubList).

• Lapangan counter sing nyimpen jumlah unsur sing bener ing array:

  private int size

  Nilai kasebut ditambah / dikurangi nalika nindakake operasi kayata sisipan lan pambusakan.

Ana 3 lapangan liyane ing kelas, nanging ateges padha tambahan, supaya ora ana gunane ing considering. Kelas kasebut nduweni telung konstruktor:

1. public ArrayList()- nggawe dhaptar dhaptar kosong saka 10 unsur;
2. public ArrayList(Collection < ? extends E > c)- nggawe array dhaptar sing diinisialisasi karo unsur saka koleksi sing dilewati (yen kita pengin nggawe ArrayList anyar adhedhasar sawetara koleksi);
3. public ArrayList(int initialCapacity)- nggawe dhaptar dhaptar kanthi kapasitas wiwitan. Yen parameter sing dilewati initialCapacity luwih saka 0, banjur array saka ukuran sing ditemtokake digawe (field internal elementData diwenehi link menyang array anyar saka jinis Obyek ukuran initialCapacity). Yen parameter 0, banjur array kosong digawe. Yen parameter sing ditemtokake kurang saka 0, banjur IllegalArgumentException dibuwang.

Nggawe Obyek

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

Obyek sing mentas digawe listngemot properti (kolom) elementDatalan size. Toko nilai elementDataora luwih saka array saka jinis tartamtu (ditemtokake ing generik – <>), ing kasus kita String[]. Yen konstruktor tanpa paramèter diarani, banjur kanthi standar bakal nggawe array saka 10 unsur jinis Obyek (kanthi casting kanggo jinis, mesthi). Nambahake unsur Klasik nambahake unsur menyang larik dhaptar ditindakake kanthi nggunakake varian sing kakehan beban add().

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

Inggih, ayo nambah: list.add("0"); Ing cara iki, versi overloaded saka cara disebut add(), ditandhani minangka private, kang siji njupuk telung paramèter minangka input: unsur sing bakal ditambahake, Uploaded internal lan ukuran. Ing metode pribadhi, ana mriksa: yen parameter ukuran sing dilewati padha karo dawa array internal (yaiku, array kebak), banjur array diwenehi asil metode kasebut grow(int minCapacity)(nilai saiki lapangan. ukuran + 1 diterusake menyang metode kasebut, amarga kudu digatekake unsur sing ditambahake), ing ngendi array internal diwenehi link menyang array sing digawe anyar sing dipikolehi kanthi nyalin unsur array asli:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Minangka parameter kaloro saka cara, copyOfkita nunjukaké asil saka cara newCapacity(int minCapacity), ing kang ukuran Uploaded anyar wis diwilang. Diwilang nggunakake rumus ing ngisor iki: int newCapacity = oldCapacity + (oldCapacity >> 1) Kanggo larik karo ukuran standar, ing ngisor iki bakal bener: >> 1– bitwise shift menyang tengen dening siji (operator sing nyuda nomer kanggo setengah saka). Ateges, tegese dibagi dening 2 kanggo daya 1. Pranyata metu sing kita dibagi 10 dening 2 lan nambah 10. Total, kapasitas anyar Uploaded 15, nanging wiwit kita nambah unsur 11, banjur 15 + 1. = 16. Ayo bali menyang dhaptar lan umpamane kita wis nambahake 10 unsur lan nyoba nambah 11. Priksa bakal nuduhake yen ora ana spasi ing array. Patut, larik anyar digawe lan disebut Arrays.copyOf, kang internal nggunakake cara sistem System.arraycopy(). Utawa ing ngisor iki conto sing jelas saka siji artikel ing JavaRush: Sawise kabeh mriksa lan nambah ukuran array yen perlu, banjur kanthi cara pribadi add()unsur anyar ditambahake ing mburi array, lan parameter saiki sizetambah siji. . Larik lawas sabanjure bakal diproses dening tukang sampah. Iki minangka array dinamis: nalika kita nambah unsur, kita mriksa apa isih ana ruang. Yen ana spasi, banjur kita mung nambah unsur menyang mburi Uploaded. Pungkasan ora ateges sel pungkasan ing array, nanging sel sing cocog karo nilai size. Kita nambahake unsur pisanan menyang larik; diselehake ing sel kanthi indeks [0]. Nilai lapangan sizewis tambah siji lan = 1. Kita nambah unsur sabanjure: kita waca sing size = 1, patut kita sijine unsur ing sel karo indeks [1] lan ing. Ana versi overloaded saka cara karo rong paramèter:

public void add(int index, E element)

Kita bisa nemtokake posisi (indeks) sel ing ngendi kita pengin nambah unsur kasebut. Kaping pisanan, bener saka nilai indeks sing ditemtokake dicenthang, amarga ana kemungkinan indeks sing salah bakal ditemtokake, sing bakal nuding menyang sel sing ora ana apa-apa, utawa mung ora ana. Priksa indeks: index > size || index < 0- yen indeks sing ditemtokake luwih gedhe tinimbang ukuran array saiki utawa kurang saka 0, banjur ana pangecualian IndexOutOfBoundsException. Banjur, yen perlu, ukuran array tambah, padha karo conto ing ndhuwur. Sampeyan mbokmenawa wis krungu sing sak nambah / mbusak operasi ing Uploaded, soko wis pindah nang endi wae (salah siji menyang tengen utawa ngiwa). Dadi, shift ditindakake kanthi nyalin array: System.arraycopy(elementData, index, elementData, index + 1, s - index); Kabeh unsur sing ana ing sisih tengen indeks sing ditemtokake bakal dialihake siji posisi menyang sisih tengen (indeks + 1). Lan mung sawise unsur anyar ditambahake menyang array internal ing indeks kasebut. Amarga kita wis mindhah bagean saka array menyang sisih tengen kanthi siji (array anyar ora digawe), sel sing kita butuhake bakal gratis kanggo nulis. Link menyang array lawas wis dibusak lan ing mangsa ngarep bakal dijupuk dening tukang sampah. Tempel "maserati" ing sel [3], sing wis dikuwasani: Mangkono, nalika unsur dilebokake ing indeks lan ora ana spasi free ing Uploaded, telpon System.arraycopy()bakal kelakon kaping pindho: pisanan ing grow(), kaloro ing cara dhewe add(index, value), kang cetha bakal mengaruhi kacepetan kabeh operasi nambah. Akibaté, nalika perlu kanggo nulis unsur liyane menyang array internal, nanging ora ana spasi, banjur iki kedadeyan ing ArrayList:

• Larik anyar digawe kanthi ukuran 1,5 kaping luwih gedhe tinimbang sing asli, ditambah siji unsur.
• Kabeh unsur saka larik lawas disalin menyang larik anyar
• Array anyar disimpen ing variabel internal obyek ArrayList, lan array lawas diumumake sampah.

Kapasitas obyek saka jinis ArrayList bisa ditambah kanthi manual nggunakake metode:

public void ensureCapacity(int minCapacity)

Kanthi nambah kapasitas Uploaded ing advance, sampeyan bisa supaya redistribusi tambahan RAM mengko. Cara nambah ukuran array internal kanggo nampung jumlah unsur liwati menyang minCapacity. Cara kasebut ensureCapacity()ora mengaruhi lapangan size, mengaruhi capacity(ukuran) array internal. Sepisan maneh aku nandheske sing sizeloro iku capacitybeda lan iku penting banget kanggo ora galau! Yen sampeyan pengin ngurangi ukuran array ndasari saka kang ArrayList dibangun kanggo nomer saiki unsur bener disimpen, sampeyan kudu nelpon trimToSize(). Sawise njabut unsur saka koleksi, size()bakal nuduhake nomer unsur bener ana, lan capacityora bakal suda! Upaminipun: kita ngetik 100 unsur, dibusak pisanan 50, sizeiku bakal padha karo 50, lan capacitybakal tetep 100. Kanggo ngurangi lan capacity, kita kudu nggunakake cara trimToSize(), kang nyetel kabeh kapasitas kanggo ukuran saiki. Carane cocog? Nyalin larik supaya ora ana sel kosong sing isih ana (dawa larik anyar mung padha karo kolom ukuran). Sampeyan uga bisa nambah unsur menyang koleksi kita nggunakake addAll.

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

Opsi pisanan ngidini sampeyan nambah kabeh unsur saka koleksi sing ditemtokake ing parameter metode (contone, sheet liyane) menyang koleksi asli (sisipake ing mburi) sing diarani metode kasebut. Koleksi liwati (uga bisa dadi set) diowahi dadi array nggunakake toArray(). Alami, operasi nambah uga ditindakake kanthi nyalin. Kapindho yaiku nambahake kabeh unsur collectionmenyang dhaptar, wiwit saka indeks index. Ing kasus iki, kabeh unsur bakal pindhah menyang tengen kanthi jumlah unsur ing dhaftar collection. Mbusak unsur Kawitan, ayo kang katon ing opsi klasik kanggo mbusak unsur saka ArrayList.

public E remove(int index)

Nindakake pambusakan kanthi indeks lan nggeser kabeh unsur sakteruse (sawise unsur ing indeks sing ditemtokake) menyang kiwa, kanthi mangkono nutup "bolongan". Iki uga ngasilake unsur sing wis dibusak (E), sing sadurunge ditulis menyang variabel tambahan sadurunge pambusakan, nilai sing dipikolehi minangka asil saka telpon metode. Kanggo mangerteni apa E iku, sampeyan kudu ngerti apa sing diarani jinis generik. Notasi E nuduhake yen cara ngasilake jinis data sing ditemtokake nalika nggawe obyek ArrayList (elinga: List <String> list, Mangkono, ing kasus iki, E bakal "diganti" String). Kanggo pangerten umum, aku banget nyaranake sampeyan familiarize dhewe karo jinis umum. Kebeneran indeks sing dilebokake dicenthang, banjur ing metode kasebut, unsur kasebut ora dibusak kanthi lengkap, nanging metode pribadi diarani fastRemove(Object[] es, int i), sing wis ana pambusakan. Kita ngirim array lan indeks sing ditemtokake menyang metode minangka input. Unsur sing disalin nggunakake System.arraycopy(), ukuran Uploaded suda, lan banjur kita nemtokake null kanggo unsur pungkasan. Wigati dicathet menawa array anyar ora digawe: System.arraycopy(es, i + 1, es, i, size - 1 - i); Bagean sing ana ing sisih tengen posisi ing indeks sing ditemtokake (i+1) disalin menyang array asli kita (es), lan dumunung wiwit saka posisi banget. (i) ing ngendi unsur kasebut bakal dibusak. Mangkono, kita nindakake shift ngiwa lan mbusak unsur kita. Coba mbusak unsur ing indeks 3 saka larik ing ngisor iki: Ayo nimbang versi kapindho cara:

public boolean remove(Object o)

Cara mbusak unsur liwati saka dhaftar o, utawa luwih tepat, obyek ing link kasebut. Yen ana unsur ing dhaptar, bakal dibusak lan kabeh unsur dipindhah menyang kiwa. Yen unsur kasebut ana ing dhaptar lan kasil dibusak, cara kasebut bakal bali bener; yen ora, salah. Kaya pilihan kanthi mbusak kanthi indeks, metode kasebut diarani fastRemove(), ing ngendi tumindak sing padha kedadeyan. Bentenane yaiku metode kasebut remove(Object o)uga nggoleki obyek sing dikarepake liwat metode equals()kelas Obyek. Nalika njabut dening Nilai, daur ulang liwat kabeh unsur dhaftar nganti cocog ketemu. Mung unsur pisanan sing ditemokake bakal dibusak. Ayo ngringkes: nalika mbusak unsur saka array dinamis, ora ana bolongan sing ditinggalake kaya ing array biasa (sel sing wis dibusak ora bakal kosong). Kabeh unsur sakteruse (sing ana ing sisih tengen indeks) dipindhah siji posisi ngiwa. Ana sawetara cara tambahan sing bisa digunakake kanggo mbusak unsur saka dhaftar kanggo macem-macem derajat. Ayo padha ndeleng sedhela. Reresik koleksi kita:

public void clear()

A daur ulang prasaja foriterates liwat kabeh unsur array, nemtokake null kanggo saben unsur. Sampeyan bisa mbusak unsur kasebut saka koleksi kita sing ana ing koleksi liyane sing ditransfer kaya iki:

public boolean removeAll(Collection< ?> c)

Yen sampeyan kudu mbusak sawetara unsur, sampeyan mbokmenawa ora kudu nindakake ing daur ulang kondisional: iku luwih trep lan luwih aman kanggo nggunakake cara removeAll(). Iku nampa koleksi unsur sing bakal dibusak saka dhaftar. Koleksi kasebut kudu ngemot unsur sing padha karo sing disimpen ing dhaptar target. Yen ora bakal dibuwang ClassCastException. Cara bakal bali bener yen dhaptar diganti minangka asil saka telpon cara. Mbusak unsur sing ora kalebu ing koleksi sing dilewati:

public boolean retainAll(Collection< ?> c)

Ayo kita duwe koleksi:

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

Lan kapindho:

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

Banjur sawise listSecond.retainAll(listFirst)ing listSecondbakal tetep:

"White"
"Red"

Wiwit "Ijo" dibusak, sing ora ana ing listFirst. Nanging sawise listSecond.removeAll(listFirst)iku listSecondbakal tetep:

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

Ora kalebu koleksi sing dilewati - tegese yen ana unsur sing ora ana ing koleksi sing dilewati, mula sampeyan kudu nyopot saka sing pertama (sing ditrapake metode kasebut). Duwe koleksi sing ditransfer - mula, yen ana unsur ing koleksi pisanan lan kaloro (ditransfer), banjur duplikat saka sing pisanan dirusak.

protected void removeRange(int fromIndex, int toIndex)

Mbusak saka dhaptar kabeh unsur sing ana ing antarane indeks sing ditemtokake wiwitan (kalebu) lan indeks sing ditemtokake pungkasan (ora kalebu). Wigati dicathet yen metode kasebut ora bisa diarani langsung ing obyek ArrayList. Kanggo nggunakake sampeyan kudu oleh warisan saka AbstractList/ArrayList. Cara kasebut uga digunakake kanthi cara liya (subList, sing bakal dibahas mengko).

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

Mbusak unsur saka koleksi adhedhasar predikat tartamtu. Predikat dhewe minangka fungsi / algoritma / kondisi tartamtu kanthi basis siji utawa luwih unsur sing cocog karo kondisi tartamtu bakal dibusak. Predicate- antarmuka fungsional (mung ngemot siji cara, supaya bisa digunakake minangka lambda), dianggo ing prinsip "nampa siji parameter - bali boolean". Ateges, cara overrides implementasine saka antarmuka Collectionlan ngleksanakake "strategi" ing ngisor iki: daur ulang liwat unsur lan menehi tandha sing cocog kita Predicate; iku banjur mbukak liwat kaping pindho kanggo mbusak (lan shift) unsur sing ditandhani ing pengulangan pisanan. Ayo ngleksanakake antarmuka Predicatesing bakal ngasilake bener yen rong obyek padha:

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

Ing kelas liyane, ayo nggawe ArrayList saka Stringlan obyek saka kelas kita sing ngetrapake Predicate:

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

varc1Ayo nulis nilai "Putih" menyang variabel :

filter.varc1 = "White";

Ayo nambah sawetara baris menyang dhaptar:

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

Ayo nglakokake metode kasebut ing dhaptar removeIf, sing bakal ditindakake obyek kanthi kondisi:

color_list.removeIf(filter);

Akibaté, kabeh baris kanthi nilai "Putih" bakal dibusak saka dhaftar, amarga kita "predikat" mbandhingaké padha kanggo podo. Dhaptar pungkasan: [Ireng, Abang, Kuning]. Ngganti unsur

public E set(int index, E element)

Ngganti unsur ing posisi sing ditemtokake indexkaro sing liwati element. Indeks kasebut uga kudu luwih gedhe tinimbang nol lan kurang saka indeks unsur pungkasan, yen ora, pangecualian bakal dibuwang IndexOutOfBoundsException. Ora ana salinan array internal. Cukup, tinimbang unsur ing indeks sing ditemtokake, unsur anyar dilebokake, i.e. nimpa nilai.

public void replaceAll(UnaryOperator<e> operator)

Ngganti kabeh unsur koleksi (bisa uga ana syarat). Biasane digunakake ing kombinasi karo lambdas utawa kelas anonim (nanging kanggo gamblang, ing conto kita mung bakal nggunakake kelas sing ngleksanakake antarmuka) sing ngleksanakake antarmuka UnaryOperatorlan nemtokake cara. Ayo ngleksanakake antarmuka:

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

Ing kelas liyane, ayo nggawe ArrayList saka Stringlan obyek saka kelas kita sing ngetrapake UnaryOperator:

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

varc1Ayo nulis nilai "Putih" menyang variabel :

operator.varc1 = "White";

Ayo nambah sawetara baris menyang dhaptar:

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

Ayo nglakokake metode ing dhaptar replaceAllsing bakal ditindakake obyek operator:

color_list.replaceAll(operator);

Akibaté, kabeh nilai ing dhaptar diganti karo "Putih": [Putih, Putih, Putih, Putih, Putih, Putih]. Lan iki carane, contone, sampeyan bisa mbusak kabeh spasi saka strings sing ana ing koleksi:

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

Cara liya: Sampeyan bisa ngowahi array dhaptar ArrayList dadi array biasa kanthi nggunakake metode:

public Object[] toArray()

utawa

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

- ing kene jinis array bali ditemtokake ing runtime Cara iki bakal ngidini:

1. nyepetake sawetara operasi;
2. pass array minangka parameter kanggo cara sing ora overloaded kanggo nampa koleksi langsung;
3. Nggabungake kode basis koleksi anyar karo kode warisan sing ora ngenali koleksi.

Mbalikake obyek salinan saka array:

public Object clone()

Wigati dimangerteni manawa metode kasebut clone()ngasilake jinis Obyek, dadi sawise nelpon sampeyan kudu ngirim menyang kelas sing dibutuhake. Kloning nggawe obyek independen anyar. Priksa koleksi kanggo anané obyek:

public boolean contains(Object o)

Priksa manawa ana obyek ing dhaptar (internal nggunakake metode sing padha karo kelas Obyek, yaiku mbandhingake referensi), ngasilake bener / salah gumantung saka asil. Saliyane puteran sing biasa, sampeyan bisa ngulang (ngakses saben unsur, uga nindakake sawetara tumindak) koleksi nggunakake:

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

Mangkene carane kita bisa nampilake dhaptar kita:

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

Tanpa nggunakake lambdas sampeyan kudu nggunakake kelas anonim lan ngganti cara acceptantarmuka Consumer:

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

Entuk unsur kanthi indeks:

public E get(int index)

Digunakake kanggo akses acak kanggo unsur koleksi. Ngasilake unsur sing ana ing dhaptar ing indeks sing ditemtokake. Yen index < 0utawa index >=jumlah maksimum unsur ing dhaftar, pangecualian bakal di buwang IndexOutOfBoundsException. Iki minangka cara dhasar kanggo njupuk unsur saka dhaftar, lan wektu kanggo njupuk unsur dening indeks bakal tansah padha, preduli saka ukuran ArrayList, awit iku ngakses sel Uploaded tartamtu. Nemokake indeks kanggo obyek tartamtu:

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

Cara kasebut ngasilake indeks saka unsur pisanan (nalika obyek sing diwenehi pisanan ditemoni) utawa kedadeyan pungkasan (nalika obyek pungkasan ditemokake) unsur ing dhaptar. Yen unsur ora ana ing dhaftar, cara bakal bali -1. Priksa koleksi kanggo unsur:

public boolean isEmpty();

Cara ngasilake bener yen dhaptar kosong (katon kanggo ndeleng yen lapangan padha size 0), digunakake palsu. Yen dhaptar mung ngemot unsur null, cara kasebut bakal ngasilake palsu. Ing tembung liyane, unsur null uga dijupuk menyang akun dening cara iki. Temokake jumlah unsur ing dhaptar:

public int size();

Ngasilake jumlah unsur ing dhaptar (nilai lapangan ukuran). Jumlah unsur bisa beda-beda saka kapasitas dhaftar (kapasitas). Entuk iterator kanggo dhaptar:

public Iterator< E> iterator();

Ngasilake iterator kanggo dhaptar kanggo nggunakake mengko ing daur ulang utawa pangolahan liyane. Iterator ngleksanakake prilaku gagal-cepet. Yen mbukak liwat koleksi lan sok dong mirsani sawetara modifikasi menyang (sing ora dijupuk nggunakake cara iterator), iku langsung mbalang pangecualian ConcurrentModificationException. Iterator duwe sing diarani modification count. Nalika iterator iterates liwat koleksi sawise saben next/hasNext/remove, mriksa counter iki. Yen ora cocog apa iterator samesthine kanggo ndeleng, mbalang pangecualian. Aku ora bakal nganggep iterator kanthi rinci ing kene.

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

Ngasilake iterator dhaptar kanggo dhaptar kanggo panggunaan mengko ing daur ulang utawa pangolahan liyane. Antarmuka ListIteratorngluwihi antarmuka Iteratorkanggo traversal rong arah saka dhaptar lan modifikasi saka sawijining unsur. Ing versi overloaded, sampeyan bisa ngliwati indeks saka ngendi "traversal" bakal diwiwiti. Indeks ing kasus iki nuduhake unsur pisanan saka kang cara bakal miwiti karya next(), lan nalika cara disebut, previous()traversal bakal miwiti saka unsur ing indeks "lulus indeks - 1".

public Spliterator <E> spliterator()

Java 8 ngenalake jinis iterator pungkasan lan cepet-cepet sing diarani iterator delimiter. Separator iterator ngijini sampeyan kanggo iterate liwat urutan unsur, nanging padha digunakake ing cara sing beda. Fitur paling penting saka antarmuka Spliterator iku kemampuan kanggo ndhukung pengulangan podo saka bagean individu saka urutan unsur, lan mulane program podo.