Analisis mendetail tentang kelas ArrayList [Bagian 1]

Artikel ini akan membahas secara mendetail kelas ArrayList dari Collections Framework, yang mungkin paling mudah dipahami, karena faktanya kelas ini didasarkan pada array biasa. Anda hampir pasti akan ditanyai pertanyaan tentang kelas ini dan implementasinya di Java saat wawancara. Pada bagian kedua kita akan menganalisis metode yang tersisa dan menulis implementasi kita sendiri terhadap array dinamis untuk angka. Kelas ArrayList mewarisi dari kelas AbstrakList dan mengimplementasikan antarmuka berikut: List, RandomAccess, Cloneable, Serializable. Analisis mendetail tentang kelas ArrayList [Bagian 2] Kelas ArrayList mendukung array dinamis yang dapat diperluas sesuai kebutuhan. Kebutuhan dan keefektifannya dijelaskan oleh fakta bahwa larik biasa memiliki panjang yang tetap: setelah dibuat, larik tersebut tidak dapat bertambah atau menyusut, sehingga menimbulkan batasan jika tidak diketahui seberapa besar larik yang dibutuhkan. Pada dasarnya, kelas ArrayList adalah array daftar referensi objek dengan panjang variabel. Penting untuk dipahami bahwa ukuran (jumlah sel) array internal tidak secara otomatis berkurang ketika elemen dihapus darinya. Faktanya, nilai variabel size, yang menunjukkan jumlah elemen yang sebenarnya ada dalam array, mengalami penurunan. Katakanlah kita membuat objek baru dari kelas ArrayList dan menambahkan 5 elemen ke dalamnya. Secara default, array yang terdiri dari 10 elemen dibuat. Dalam hal ini, yang disebut kapasitas (ukuran/volume) objek kita akan sama dengan 10, namun nilai variabelnya sizeakan sama dengan lima. Dan ketika kita menghapus elemen, kita melihat perubahan nilai variabel size, karena kita .lengthtidak dapat mengakses array internal kelas ArrayList dan mengetahui panjangnya. Ukurannya dapat diperkecil menggunakan metode tambahan trimToSize(), yang akan dibahas nanti. Mari kita lihat bidang kelas.

• Bidang yang bertanggung jawab atas volume default array dinamis:

  private static final int DEFAULT_CAPACITY = 10

  Saat membuat objek baru new ArrayList<>() (konstruktor tanpa parameter), array 10 elemen dibuat di dalamnya.

• Bidang tempat semua elemen koleksi disimpan:

  transient Object[] elementData

  Ditandai dengan kata kunci transient- bidang tidak ditulis ke aliran byte saat menggunakan algoritma serialisasi standar. Perlu dicatat bahwa bidang ini tidak ditandai dengan kata kunci private, tetapi hal ini dilakukan untuk memfasilitasi akses ke bidang ini dari kelas bertingkat (misalnya, SubList).

• Bidang penghitung yang menyimpan jumlah elemen sebenarnya dalam larik:

  private int size

  Nilainya bertambah/berkurang saat melakukan operasi seperti penyisipan dan penghapusan.

Ada 3 bidang lagi di kelas tersebut, tetapi pada dasarnya bidang tersebut tambahan, jadi tidak ada gunanya mempertimbangkannya. Kelas memiliki tiga konstruktor:

1. public ArrayList()– membuat array daftar kosong yang terdiri dari 10 elemen;
2. public ArrayList(Collection < ? extends E > c)– membuat array daftar yang diinisialisasi dengan elemen dari koleksi yang diteruskan (jika kita ingin membuat ArrayList baru berdasarkan beberapa koleksi);
3. public ArrayList(int initialCapacity)– membuat array daftar dengan kapasitas awal. Jika parameter yang diteruskan InitialCapacity lebih besar dari 0, maka array dengan ukuran yang ditentukan akan dibuat (bidang internal elementData diberi tautan ke array baru bertipe Object dengan ukuran InitialCapacity). Jika parameternya 0, maka array kosong akan dibuat. Jika parameter yang ditentukan kurang dari 0, maka IllegalArgumentException akan dilempar.

Membuat Objek

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

Objek yang baru dibuat listberisi properti (bidang) elementDatadan size. Penyimpanan nilai elementDatatidak lebih dari sebuah array dengan tipe tertentu (ditentukan dalam generik – <>), dalam kasus kita String[]. Jika konstruktor tanpa parameter dipanggil, maka secara default array 10 elemen bertipe Object akan dibuat (tentu saja dengan casting ke tipe tersebut). Menambahkan elemen Secara klasik menambahkan elemen ke array daftar dilakukan dengan menggunakan varian add().

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

Baiklah, mari kita tambahkan: list.add("0"); Di dalam metode ini, versi metode yang kelebihan beban dipanggil add(), ditandai sebagai private, yang kemudian mengambil tiga parameter sebagai masukan: elemen yang akan ditambahkan, array internal, dan ukurannya. Dalam metode privat, pemeriksaan terjadi: jika parameter ukuran yang diteruskan sama dengan panjang array internal (yaitu, array penuh), maka array tersebut diberi hasil metode grow(int minCapacity)(nilai bidang saat ini size + 1 diteruskan ke metode, karena elemen yang ditambahkan harus diperhitungkan), di mana internal array diberi tautan ke array yang baru dibuat yang diperoleh dengan menyalin elemen array asli:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Sebagai parameter kedua dari metode ini, copyOfkami menunjukkan hasil metode newCapacity(int minCapacity), di mana ukuran array baru dihitung. Hal ini dihitung menggunakan rumus berikut: int newCapacity = oldCapacity + (oldCapacity >> 1) Untuk array dengan ukuran default, berikut ini yang berlaku: >> 1– pergeseran bitwise ke kanan sebanyak satu (operator yang mengurangi angka menjadi setengahnya). Intinya artinya membagi 2 pangkat 1. Ternyata 10 kita bagi 2 lalu dijumlahkan 10. Total kapasitas array yang baru adalah 15, tapi karena kita menjumlahkan elemen ke-11, maka 15 + 1 = 16. Mari kita kembali ke daftar kita dan misalkan kita telah menambahkan 10 elemen ke dalamnya dan mencoba menambahkan 11. Pengecekan akan menunjukkan bahwa tidak ada spasi dalam array. Oleh karena itu, array baru dibuat dan dipanggil Arrays.copyOf, yang secara internal menggunakan metode sistem System.arraycopy(). Atau inilah contoh jelas dari salah satu artikel di JavaRush: Setelah semua pemeriksaan ini dan meningkatkan ukuran array jika perlu, maka dalam metode pribadi, add()elemen baru ditambahkan ke akhir array, dan parameter saat ini sizebertambah satu . Array lama selanjutnya akan diproses oleh pengumpul sampah. Beginilah cara kerja array dinamis: saat kita menambahkan elemen, kita memeriksa apakah masih ada ruang di dalamnya. Jika ada ruang, maka kita cukup menambahkan elemen tersebut ke akhir array. Akhir tidak berarti sel terakhir dalam array, tetapi sel yang sesuai dengan nilainya size. Kami menambahkan elemen pertama ke array; elemen itu ditempatkan di sel dengan indeks [0]. Nilai bidang sizebertambah satu dan = 1. Kita menambahkan elemen berikutnya: kita melihatnya size = 1, oleh karena itu kita menempatkan elemen di sel dengan indeks [1] dan seterusnya. Ada versi metode yang kelebihan beban dengan dua parameter:

public void add(int index, E element)

Kita dapat menentukan posisi (indeks) sel tempat kita ingin menambahkan elemen. Pertama, kebenaran nilai indeks yang ditentukan diperiksa, karena ada kemungkinan indeks yang salah akan ditentukan, yang akan menunjuk ke sel di mana tidak ada, atau tidak ada. Memeriksa indeks: index > size || index < 0– jika indeks yang ditentukan lebih besar dari ukuran array saat ini atau kurang dari 0, maka pengecualian akan diberikan IndexOutOfBoundsException. Kemudian, jika perlu, ukuran array diperbesar, mirip dengan contoh di atas. Anda mungkin pernah mendengar bahwa selama operasi tambah/hapus dalam sebuah array, ada sesuatu yang bergeser ke suatu tempat (baik ke kanan atau ke kiri). Jadi, pergeserannya dilakukan dengan menyalin array: System.arraycopy(elementData, index, elementData, index + 1, s - index); Semua elemen yang terletak di sebelah kanan indeks yang ditentukan akan digeser satu posisi ke kanan (indeks+1). Dan hanya setelah itu elemen baru ditambahkan ke array internal pada indeks yang ditentukan. Karena kita telah menggeser sebagian array ke kanan sebanyak satu (array baru tidak dibuat), sel yang kita perlukan akan bebas untuk ditulis. Tautan ke array lama dihapus dan di masa depan akan diambil alih oleh pengumpul sampah. Tempelkan "maserati" ke dalam sel [3] yang sudah terisi: Jadi, ketika sebuah elemen dimasukkan pada indeks dan tidak ada ruang kosong dalam array, panggilan System.arraycopy()akan terjadi dua kali: yang pertama in grow(), yang kedua dalam metode itu sendiri add(index, value), yang jelas akan mempengaruhi kecepatan seluruh operasi penambahan. Akibatnya, ketika elemen lain perlu ditulis ke array internal, tetapi tidak ada ruang di sana, maka inilah yang terjadi di dalam ArrayList:

• Array baru dibuat dengan ukuran 1,5 kali lebih besar dari array asli, ditambah satu elemen.
• Semua elemen dari array lama disalin ke array baru
• Array baru disimpan dalam variabel internal objek ArrayList, dan array lama dinyatakan sampah.

Kapasitas objek bertipe ArrayList dapat ditingkatkan secara manual menggunakan metode:

public void ensureCapacity(int minCapacity)

Dengan meningkatkan kapasitas array terlebih dahulu, Anda dapat menghindari redistribusi RAM tambahan di kemudian hari. Metode ini meningkatkan ukuran array internal untuk mengakomodasi jumlah elemen yang diteruskan ke minCapacity. Metode ini ensureCapacity()tidak mempengaruhi field size, ini mempengaruhi capacity(ukuran) array internal. Sekali lagi saya tekankan bahwa sizekeduanya adalah capacityhal yang berbeda dan sangat penting untuk tidak membingungkannya! Jika Anda ingin mengurangi ukuran larik dasar tempat ArrayList dibuat hingga jumlah elemen yang sebenarnya disimpan saat ini, Anda harus memanggil fungsi trimToSize(). Setelah menghapus elemen dari koleksi, size()jumlah elemen yang sebenarnya ada akan ditampilkan, dan capacitytidak akan berkurang! Misalkan: kita memasukkan 100 elemen, menghapus 50 elemen pertama, sizemenjadi sama dengan 50, sehingga capacitytetap 100. Untuk mengurangi dan capacity, kita perlu menggunakan metode trimToSize(), yang menyesuaikan seluruh kapasitas kita dengan ukuran saat ini. Bagaimana kesesuaiannya? Menyalin array kita sehingga tidak ada sel kosong yang tersisa (panjang array baru sama dengan ukuran kolom). Anda juga dapat menambahkan elemen ke koleksi kami menggunakan addAll.

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

Opsi pertama memungkinkan Anda untuk menambahkan semua elemen dari koleksi yang ditentukan dalam parameter metode (misalnya, lembar lain) ke koleksi asli (masukkan di akhir) tempat pemanggilan metode dilakukan. Koleksi yang diteruskan (bisa juga berupa kumpulan) diubah menjadi array menggunakan ekstensi toArray(). Tentu saja, operasi penambahan juga dilakukan dengan menggunakan penyalinan. Yang kedua adalah menambahkan semua elemen collectionke daftar, mulai dari indeks index. Dalam hal ini, semua elemen akan bergeser ke kanan sesuai jumlah elemen dalam list collection. Menghapus elemen Pertama, mari kita lihat opsi klasik untuk menghapus elemen dari ArrayList.

public E remove(int index)

Melakukan penghapusan berdasarkan indeks dan menggeser semua elemen berikutnya (setelah elemen pada indeks yang ditentukan) ke kiri, sehingga menutup “lubang”. Ini juga mengembalikan elemen yang dihapus (E), yang sebelumnya ditulis ke variabel tambahan sebelum dihapus, yang nilainya kita peroleh sebagai hasil dari pemanggilan metode. Untuk memahami apa itu E, Anda perlu mengenal apa yang disebut tipe generik. Notasi E menunjukkan bahwa metode mengembalikan tipe data yang ditentukan saat membuat objek ArrayList (ingat: List <String> list, oleh karena itu, dalam hal ini, E akan “diganti” String). Untuk pemahaman umum, saya sangat menyarankan Anda membiasakan diri dengan tipe generik. Kebenaran indeks yang dimasukkan diperiksa, dan kemudian di dalam metode, elemen tersebut tidak sepenuhnya dihapus, tetapi metode pribadi disebut fastRemove(Object[] es, int i), di mana penghapusan sudah terjadi. Kami meneruskan array kami dan indeks yang ditentukan ke metode sebagai masukan. Elemen-elemen tersebut disalin menggunakan System.arraycopy(), ukuran array dikurangi, dan kemudian kami menetapkan null ke elemen terakhir. Perlu dicatat bahwa array baru tidak dibuat: System.arraycopy(es, i + 1, es, i, size - 1 - i); Bagian yang berada di sebelah kanan posisi di bawah indeks yang ditentukan (i+1) disalin ke dalam array asli kita (es), dan lokasinya dimulai dari posisi paling atas. (i) di mana elemen itu berada yang akan dihapus. Jadi, kami melakukan pergeseran ke kiri dan menghapus elemen kami. Mari kita coba menghapus elemen pada indeks 3 dari array di bawah ini: Mari kita pertimbangkan versi kedua dari metode ini:

public boolean remove(Object o)

Metode ini menghapus elemen yang diteruskan dari daftar o, atau lebih tepatnya, objek pada tautan yang ditentukan. Jika suatu elemen ada dalam daftar, maka elemen tersebut akan dihapus dan semua elemen digeser ke kiri. Jika elemen ada dalam daftar dan berhasil dihapus, metode akan mengembalikan nilai benar; jika tidak, salah. Mirip dengan opsi penghapusan berdasarkan indeks, metode ini disebut fastRemove(), di mana tindakan yang persis sama terjadi. Bedanya, metode tersebut remove(Object o)juga mencari objek yang diinginkan melalui metode equals()kelas Object. Saat menghapus berdasarkan nilai, loop melewati semua elemen daftar hingga ditemukan kecocokan. Hanya elemen pertama yang ditemukan yang akan dihapus. Mari kita rangkum: saat menghapus elemen dari array dinamis, tidak ada lubang yang tersisa seperti pada array biasa (sel yang dihapus tidak akan kosong). Semua elemen berikutnya (yang berada di sebelah kanan indeks) digeser satu posisi ke kiri. Ada beberapa metode tambahan yang dapat digunakan untuk menghapus elemen dari daftar hingga tingkat yang berbeda-beda. Mari kita lihat secara singkat. Membersihkan koleksi kami:

public void clear()

Perulangan sederhana formengulangi semua elemen array, menetapkan null ke setiap elemen. Anda dapat menghapus elemen tersebut dari koleksi kami yang terdapat dalam koleksi lain yang ditransfer seperti ini:

public boolean removeAll(Collection< ?> c)

Jika Anda perlu menghapus beberapa elemen, Anda mungkin sebaiknya tidak melakukannya dalam loop bersyarat: akan lebih nyaman dan aman menggunakan metode ini removeAll(). Ia menerima kumpulan elemen yang akan dihapus dari daftar. Koleksi harus berisi elemen dengan tipe yang sama dengan yang disimpan oleh daftar target. Jika tidak maka akan dibuang ClassCastException. Metode ini akan mengembalikan nilai true jika daftar diubah sebagai akibat dari pemanggilan metode. Menghapus elemen yang bukan milik koleksi yang diteruskan:

public boolean retainAll(Collection< ?> c)

Misalkan kita mempunyai koleksi:

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

Dan yang kedua:

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

Kemudian setelahnya listSecond.retainAll(listFirst)akan listSecondtetap:

"White"
"Red"

Karena "Hijau" telah dihapus, yang tidak ada dalam listFirst. Tapi setelah listSecond.removeAll(listFirst)itu listSecondakan tetap ada:

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

Bukan milik koleksi yang diteruskan - artinya jika ada elemen yang tidak ada dalam koleksi yang diteruskan, maka Anda harus menghapusnya dari koleksi pertama (yang metodenya diterapkan). Milik koleksi yang ditransfer - oleh karena itu, jika ada elemen di koleksi pertama dan kedua (yang ditransfer), maka duplikat dari koleksi pertama akan dimusnahkan.

protected void removeRange(int fromIndex, int toIndex)

Menghapus dari daftar semua elemen yang berada di antara indeks awal yang ditentukan (inklusif) dan indeks akhir yang ditentukan (tidak inklusif). Perlu diperhatikan bahwa metode ini tidak dapat dipanggil secara langsung pada objek ArrayList. Untuk menggunakannya, Anda perlu mewarisi dari AbstractList/ArrayList. Metode tersebut juga digunakan oleh metode lain (subList, yang akan dibahas nanti).

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

Menghapus elemen dari koleksi berdasarkan predikat tertentu. Predikat itu sendiri adalah fungsi/algoritma/kondisi tertentu yang menjadi dasar penghilangan satu atau lebih elemen yang sesuai dengan kondisi tertentu. Predicate— antarmuka fungsional (hanya berisi satu metode, sehingga dapat digunakan sebagai lambda), bekerja berdasarkan prinsip "menerima satu parameter - mengembalikan boolean". Pada dasarnya, metode ini mengesampingkan implementasi dari antarmuka Collectiondan mengimplementasikan "strategi" berikut: metode ini mengulang elemen dan menandai elemen yang cocok dengan Predicate; itu kemudian dijalankan untuk kedua kalinya untuk menghapus (dan menggeser) elemen yang ditandai pada iterasi pertama. Mari kita implementasikan antarmuka Predicateyang akan mengembalikan nilai true jika dua objek sama:

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

Di kelas lain, mari buat ArrayList dari Stringdan objek kelas kita yang mengimplementasikan Predicate:

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

varc1Mari kita tuliskan nilai "Putih" ke variabel :

filter.varc1 = "White";

Mari tambahkan beberapa baris ke daftar:

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

Mari kita jalankan metode pada list removeIf, ke mana kita akan meneruskan objek kita dengan syarat:

color_list.removeIf(filter);

Akibatnya, semua baris dengan nilai "Putih" akan dihapus dari daftar, karena "predikat" kita membandingkannya untuk kesetaraan. Daftar akhir: [Hitam, Merah, Kuning]. Mengganti elemen

public E set(int index, E element)

Menggantikan elemen pada posisi yang ditentukan indexdengan elemen yang dilewati element. Indeks juga harus lebih besar dari nol dan lebih kecil dari indeks elemen terakhir, jika tidak, pengecualian akan dilempar IndexOutOfBoundsException. Tidak ada salinan array internal yang terjadi. Sederhananya, alih-alih elemen pada indeks yang ditentukan, elemen baru dimasukkan, mis. menimpa nilainya.

public void replaceAll(UnaryOperator<e> operator)

Mengubah semua elemen koleksi (bisa dengan syarat). Sebagian besar digunakan dalam kombinasi dengan lambda atau kelas anonim (tetapi untuk kejelasan, dalam contoh kita hanya akan menggunakan kelas yang mengimplementasikan antarmuka) yang mengimplementasikan antarmuka UnaryOperatordan mendefinisikan metodenya. Mari kita implementasikan antarmukanya:

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

Di kelas lain, mari buat ArrayList dari Stringdan objek kelas kita yang mengimplementasikan UnaryOperator:

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

varc1Mari kita tuliskan nilai "Putih" ke variabel :

operator.varc1 = "White";

Mari tambahkan beberapa baris ke daftar:

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

Mari kita jalankan metode pada daftar replaceAllyang akan kita lewati objek kita operator:

color_list.replaceAll(operator);

Akibatnya, semua nilai dalam daftar diganti dengan "Putih": [Putih, Putih, Putih, Putih, Putih, Putih]. Dan beginilah, misalnya, Anda dapat menghapus semua spasi dari string yang ada di koleksi:

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

Metode lain: Anda dapat mengubah array daftar ArrayList menjadi array biasa menggunakan metode:

public Object[] toArray()

atau

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

- di sini jenis array yang dikembalikan ditentukan dalam runtime Metode ini akan memungkinkan:

1. mempercepat beberapa operasi;
2. meneruskan array sebagai parameter ke metode yang tidak kelebihan beban untuk menerima koleksi secara langsung;
3. Mengintegrasikan kode berbasis koleksi baru dengan kode lama yang tidak mengenali koleksi.

Kembalikan objek salinan array:

public Object clone()

Harap dicatat bahwa metode ini clone()mengembalikan tipe Object, jadi setelah memanggilnya Anda harus melakukan cast ke kelas yang diperlukan. Kloning menciptakan objek independen baru. Periksa koleksi untuk keberadaan suatu objek:

public boolean contains(Object o)

Memeriksa keberadaan suatu objek dalam daftar (secara internal menggunakan metode sama dengan kelas Object, yaitu membandingkan referensi), mengembalikan nilai benar/salah tergantung pada hasilnya. Selain perulangan biasa, Anda dapat mengulangi (mengakses setiap elemen, serta melakukan beberapa tindakan) koleksi menggunakan:

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

Beginilah cara kami menampilkan daftar kami:

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

Tanpa menggunakan lambda Anda perlu menggunakan kelas anonim dan mengganti metode acceptantarmuka Consumer:

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

Dapatkan elemen berdasarkan indeksnya:

public E get(int index)

Digunakan untuk akses acak ke elemen koleksi. Mengembalikan elemen yang terletak di daftar pada indeks yang ditentukan. Jika index < 0atau merupakan index >=jumlah maksimum elemen dalam daftar, pengecualian akan diberikan IndexOutOfBoundsException. Ini adalah metode dasar untuk mengambil elemen dari daftar, dan waktu untuk mengambil elemen berdasarkan indeks akan selalu sama, berapa pun ukuran ArrayList, karena ia mengakses sel array tertentu. Menemukan indeks untuk objek tertentu:

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

Metode mengembalikan indeks elemen pertama (saat objek tertentu pertama kali ditemukan) atau kemunculan terakhir (saat objek tertentu terakhir kali ditemukan) dalam daftar. Jika elemen tidak ada dalam daftar, metode akan mengembalikan -1. Periksa koleksi untuk elemen:

public boolean isEmpty();

Metode ini mengembalikan nilai benar jika daftarnya kosong (melihat apakah bidangnya sama dengan size 0), jika tidak, salah. Jika daftar hanya berisi elemen nol, metode akan mengembalikan nilai salah. Dengan kata lain, elemen null juga diperhitungkan dengan metode ini. Cari tahu jumlah elemen dalam daftar:

public int size();

Mengembalikan jumlah elemen dalam daftar (ukuran nilai bidang). Jumlah elemen mungkin berbeda dari daftar kapasitas (capacity). Dapatkan iterator untuk daftar:

public Iterator< E> iterator();

Mengembalikan iterator untuk daftar untuk digunakan nanti dalam satu lingkaran atau pemrosesan lainnya. Iterator mengimplementasikan perilaku gagal-cepat. Jika ia menjalankan koleksi dan melihat beberapa modifikasi pada koleksi tersebut (yang tidak diperoleh menggunakan metode iterator), ia akan segera memunculkan pengecualian ConcurrentModificationException. Iterator memiliki sesuatu yang disebut modification count. Ketika iterator melakukan iterasi melalui koleksi setelah masing-masing next/hasNext/remove, ia memeriksa penghitung ini. Jika tidak sesuai dengan apa yang diharapkan oleh iterator, maka akan muncul pengecualian. Saya tidak akan mempertimbangkan iterator secara detail di sini.

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

Mengembalikan daftar iterator untuk daftar untuk digunakan nanti dalam satu lingkaran atau pemrosesan lainnya. Antarmuka ListIteratormemperluas antarmuka Iteratoruntuk traversal dua arah dari daftar dan modifikasi elemen-elemennya. Dalam versi yang kelebihan beban, Anda dapat meneruskan indeks dari mana “traversal” akan dimulai. Indeks dalam hal ini menunjukkan elemen pertama dari mana metode akan mulai bekerja next(), dan ketika metode dipanggil, previous()traversal akan dimulai dari elemen di bawah indeks “passed index - 1”.

public Spliterator <E> spliterator()

Java 8 memperkenalkan tipe baru dari iterator pengikatan lambat dan cepat gagal yang disebut iterator pembatas. Iterator pemisah memungkinkan Anda mengulangi serangkaian elemen, tetapi digunakan dengan cara yang berbeda. Fitur paling penting dari antarmuka Spliterator adalah kemampuannya untuk mendukung iterasi paralel dari masing-masing bagian dari rangkaian elemen, dan oleh karena itu pemrograman paralel.