Analisis terperinci kelas ArrayList [Bahagian 1]

Artikel ini akan melihat secara terperinci kelas ArrayList daripada Rangka Kerja Koleksi, yang mungkin merupakan yang paling mudah untuk difahami, disebabkan fakta bahawa ia berdasarkan tatasusunan biasa. Anda hampir pasti akan ditanya soalan tentang kelas ini dan pelaksanaannya di Java semasa temu duga. Di bahagian kedua kami akan menganalisis kaedah yang tinggal dan menulis pelaksanaan tatasusunan dinamik kami sendiri untuk nombor. Kelas ArrayList mewarisi daripada kelas AbstractList dan melaksanakan antara muka berikut: List, RandomAccess, Cloneable, Serializable. Analisis terperinci kelas ArrayList [Bahagian 2] Kelas ArrayList menyokong tatasusunan dinamik yang boleh dikembangkan mengikut keperluan. Keperluan dan keberkesanannya dijelaskan oleh fakta bahawa tatasusunan biasa mempunyai panjang tetap: sebaik sahaja ia dicipta, ia tidak boleh membesar atau mengecut, yang mengenakan sekatan jika ia tidak diketahui berapa besar tatasusunan yang diperlukan. Pada asasnya, kelas ArrayList ialah tatasusunan senarai panjang boleh ubah rujukan objek. Adalah penting untuk memahami bahawa saiz (bilangan sel) tatasusunan dalaman tidak berkurangan secara automatik apabila elemen dialih keluar daripadanya. Malah, nilai pembolehubah size, yang menunjukkan bilangan elemen yang sebenarnya terdapat dalam tatasusunan, dikurangkan. Katakan kita mencipta objek baharu kelas ArrayList dan menambah 5 elemen padanya. Secara lalai, tatasusunan 10 elemen dicipta. Dalam kes ini, kapasiti yang dipanggil (saiz/isipadu) objek kita akan bersamaan dengan 10, tetapi nilai pembolehubah sizeakan sama dengan lima. Dan apabila kita memadamkan elemen, kita melihat perubahan dalam nilai pembolehubah size, kerana kita .lengthtidak boleh mengakses tatasusunan dalaman kelas ArrayList dan mengetahui panjangnya. Saiz boleh dikurangkan menggunakan kaedah tambahan trimToSize(), yang akan dibincangkan kemudian. Mari lihat medan kelas.

• Medan yang bertanggungjawab untuk volum lalai tatasusunan dinamik:

  private static final int DEFAULT_CAPACITY = 10

  Apabila mencipta objek baharu ArrayList baharu<>() (pembina tanpa parameter), tatasusunan 10 elemen dicipta di dalam.

• Medan di mana semua elemen koleksi disimpan:

  transient Object[] elementData

  Ditandakan dengan kata kunci transient- medan tidak ditulis pada strim bait apabila menggunakan algoritma siri standard. Perlu diingat bahawa medan tidak ditandakan dengan kata kunci private, tetapi ini dilakukan untuk memudahkan akses kepada medan ini daripada kelas bersarang (contohnya, SubList).

• Medan pembilang yang menyimpan bilangan elemen sebenarnya dalam tatasusunan:

  private int size

  Nilai ditambah/dikurangkan apabila melakukan operasi seperti sisipan dan pemadaman.

Terdapat 3 lagi bidang dalam kelas, tetapi pada asasnya ia adalah tambahan, jadi tidak ada gunanya mempertimbangkannya. Kelas ini mempunyai tiga pembina:

1. public ArrayList()– mencipta tatasusunan senarai kosong 10 elemen;
2. public ArrayList(Collection < ? extends E > c)– mencipta tatasusunan senarai yang dimulakan dengan elemen daripada koleksi yang diluluskan (jika kita mahu mencipta ArrayList baharu berdasarkan beberapa koleksi);
3. public ArrayList(int initialCapacity)– mencipta tatasusunan senarai dengan kapasiti awal. Jika initialCapacity parameter yang dilalui lebih besar daripada 0, maka tatasusunan saiz yang ditentukan dibuat (elemen medan dalaman diberikan pautan kepada tatasusunan baharu jenis Objek bersaiz initialCapacity). Jika parameter ialah 0, maka tatasusunan kosong dibuat. Jika parameter yang ditentukan kurang daripada 0, maka IllegalArgumentException dilemparkan.

Mencipta Objek

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

Objek yang baru dibuat listmengandungi sifat (medan) elementDatadan size. Penyimpan nilai elementDatatidak lebih daripada tatasusunan jenis tertentu (dinyatakan dalam generik – <>), dalam kes kami String[]. Jika pembina tanpa parameter dipanggil, maka secara lalai tatasusunan 10 elemen jenis Objek akan dibuat (dengan cast ke jenis, sudah tentu). Menambah elemen Menambah elemen secara klasik pada tatasusunan senarai dilakukan menggunakan varian terlampau beban add().

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

Baiklah, mari tambahkan: list.add("0"); Di dalam kaedah ini, versi kaedah yang terlebih muatan add()dipanggil, ditandakan sebagai private, yang seterusnya mengambil tiga parameter sebagai input: elemen yang akan ditambah, tatasusunan dalaman dan saiznya. Dalam kaedah persendirian, semakan berlaku: jika parameter saiz yang diluluskan adalah sama dengan panjang tatasusunan dalaman (iaitu tatasusunan penuh), maka tatasusunan diberikan hasil kaedah grow(int minCapacity)(nilai semasa medan saiz + 1 diserahkan kepada kaedah, kerana ia perlu mengambil kira elemen yang ditambah), di mana tatasusunan dalaman diberikan pautan ke tatasusunan baru yang dibuat yang diperolehi dengan menyalin elemen tatasusunan asal:

Arrays.copyOf(elementData, newCapacity(minCapacity))

Sebagai parameter kedua kaedah, copyOfkami menunjukkan hasil kaedah newCapacity(int minCapacity), di mana saiz tatasusunan baharu dikira. Ia dikira menggunakan formula berikut: int newCapacity = oldCapacity + (oldCapacity >> 1) Untuk tatasusunan dengan saiz lalai, perkara berikut adalah benar: >> 1– anjakan bit ke kanan dengan satu (pengendali yang mengurangkan nombor kepada separuh daripadanya). Pada asasnya, ini bermakna membahagikan dengan 2 kepada kuasa 1. Ternyata kita membahagi 10 dengan 2 dan menambah 10. Jumlah, kapasiti baharu tatasusunan ialah 15, tetapi kerana kita menambah elemen ke-11, maka 15 + 1 = 16. Mari kembali ke senarai kami dan andaikan kami telah menambah 10 elemen padanya dan cuba menambah 11. Semakan akan menunjukkan bahawa tiada ruang dalam tatasusunan. Sehubungan itu, tatasusunan baharu dicipta dan dipanggil Arrays.copyOf, yang secara dalaman menggunakan kaedah sistem System.arraycopy(). Atau berikut adalah contoh yang jelas daripada satu artikel di JavaRush: Selepas semua pemeriksaan ini dan meningkatkan saiz tatasusunan jika perlu, maka dalam kaedah persendirian add()elemen baharu ditambahkan pada penghujung tatasusunan, dan parameter semasa sizeditambah satu . Tatasusunan lama kemudiannya akan diproses oleh pemungut sampah. Beginilah cara tatasusunan dinamik berfungsi: apabila kami menambah elemen, kami menyemak sama ada masih terdapat ruang di dalamnya. Jika terdapat ruang, maka kita hanya menambah elemen pada penghujung tatasusunan. Penghujungnya tidak bermaksud sel terakhir dalam tatasusunan, tetapi sel yang sepadan dengan nilai size. Kami menambah elemen pertama pada tatasusunan; ia diletakkan di dalam sel dengan indeks [0]. Nilai medan sizetelah meningkat sebanyak satu dan = 1. Kami menambah elemen seterusnya: kami melihat bahawa size = 1, sewajarnya kami meletakkan elemen dalam sel dengan indeks [1] dan seterusnya. Terdapat versi lebihan kaedah dengan dua parameter:

public void add(int index, E element)

Kita boleh menentukan kedudukan (indeks) sel di mana kita ingin menambah elemen. Pertama, ketepatan nilai indeks yang ditentukan disemak, kerana terdapat kemungkinan indeks yang salah akan ditentukan, yang akan menunjuk ke sel yang tiada apa-apa, atau yang tidak wujud. Menyemak indeks: index > size || index < 0– jika indeks yang ditentukan lebih besar daripada saiz tatasusunan semasa atau kurang daripada 0, maka pengecualian akan dilemparkan IndexOutOfBoundsException. Kemudian, jika perlu, saiz tatasusunan ditingkatkan, sama seperti contoh di atas. Anda mungkin pernah mendengar bahawa semasa operasi tambah/buang dalam tatasusunan, sesuatu dialihkan ke suatu tempat (sama ada ke kanan atau ke kiri). Jadi, anjakan dijalankan dengan menyalin tatasusunan: System.arraycopy(elementData, index, elementData, index + 1, s - index); Semua elemen yang terletak di sebelah kanan indeks yang ditentukan akan dialihkan satu kedudukan ke kanan (indeks+1). Dan hanya selepas itu elemen baharu ditambahkan pada tatasusunan dalaman pada indeks yang ditentukan. Memandangkan kita telah mengalihkan sebahagian daripada tatasusunan ke kanan dengan satu (tatasusunan baharu tidak dibuat), sel yang kita perlukan akan bebas untuk menulis. Pautan ke tatasusunan lama dipadamkan dan pada masa hadapan ia akan diambil alih oleh pemungut sampah. Tampal "maserati" ke dalam sel [3], yang telah diduduki: Oleh itu, apabila elemen dimasukkan pada indeks dan tiada ruang kosong dalam tatasusunan, panggilan System.arraycopy()akan berlaku dua kali: yang pertama dalam grow(), yang kedua dalam kaedah itu sendiri add(index, value), yang jelas akan menjejaskan kelajuan keseluruhan operasi penambahan. Akibatnya, apabila perlu untuk menulis elemen lain ke tatasusunan dalaman, tetapi tiada ruang di sana, maka inilah yang berlaku di dalam ArrayList:

• Tatasusunan baharu dibuat dengan saiz 1.5 kali lebih besar daripada yang asal, ditambah satu elemen.
• Semua elemen daripada tatasusunan lama disalin ke tatasusunan baharu
• Tatasusunan baharu disimpan dalam pembolehubah dalaman objek ArrayList, dan tatasusunan lama diisytiharkan sebagai sampah.

Kapasiti objek jenis ArrayList boleh ditingkatkan secara manual menggunakan kaedah:

public void ensureCapacity(int minCapacity)

Dengan meningkatkan kapasiti tatasusunan terlebih dahulu, anda boleh mengelakkan pengagihan semula RAM tambahan kemudian. Kaedah ini meningkatkan saiz tatasusunan dalaman untuk menampung bilangan elemen yang dihantar ke minCapacity. Kaedah ini ensureCapacity()tidak menjejaskan medan size, ia mempengaruhi capacity(saiz) tatasusunan dalaman. Sekali lagi saya menekankan bahawa sizekedua-duanya adalah capacityperkara yang berbeza dan adalah sangat penting untuk tidak mengelirukan mereka! Jika anda ingin mengurangkan saiz tatasusunan asas dari mana ArrayList dibina kepada bilangan elemen semasa yang sebenarnya disimpan, anda harus memanggil trimToSize(). Selepas mengalih keluar elemen daripada koleksi, size()ia akan menunjukkan bilangan elemen yang sebenarnya sedia ada, dan capacitytidak akan berkurangan! Katakan: kita memasukkan 100 elemen, memadamkan 50 yang pertama, sizeia akan menjadi sama dengan 50, jadi capacityia akan kekal 100. Untuk mengurangkan dan capacity, kita perlu menggunakan kaedah trimToSize(), yang melaraskan keseluruhan kapasiti kita kepada saiz semasa. Bagaimana ia sesuai? Salin tatasusunan kami supaya tiada sel kosong yang tinggal (panjang tatasusunan baharu hanyalah sama dengan medan saiz). Anda juga boleh menambah elemen pada koleksi kami menggunakan addAll.

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

Pilihan pertama membolehkan anda menambah semua elemen daripada koleksi yang dinyatakan dalam parameter kaedah (contohnya, helaian lain) ke koleksi asal (sisipkan di hujung) yang mana panggilan kaedah dibuat. Koleksi yang diluluskan (ia juga boleh menjadi satu set) ditukar kepada tatasusunan menggunakan toArray(). Sememangnya, operasi menambah juga dijalankan menggunakan penyalinan. Yang kedua ialah menambah semua elemen collectionpada senarai, bermula dari index index. Dalam kes ini, semua elemen akan beralih ke kanan mengikut bilangan elemen dalam senarai collection. Mengalih keluar elemen Mula-mula, mari kita lihat pilihan klasik untuk mengalih keluar elemen daripada ArrayList.

public E remove(int index)

Melakukan pemadaman mengikut indeks dan mengalihkan semua elemen berikutnya (selepas elemen pada indeks yang ditentukan) ke kiri, dengan itu menutup "lubang". Ia juga mengembalikan elemen yang dipadamkan (E), yang sebelum ini ditulis kepada pembolehubah tambahan sebelum pemadaman, nilai yang kami perolehi hasil daripada panggilan kaedah. Untuk memahami apa itu E, anda perlu membiasakan diri dengan apa yang dipanggil jenis generik. Notasi E menunjukkan bahawa kaedah mengembalikan jenis data yang ditentukan semasa mencipta objek ArrayList (ingat: List <String> list, sewajarnya, dalam kes ini, E akan "digantikan" String). Untuk pemahaman umum, saya amat mengesyorkan agar anda membiasakan diri dengan jenis generik. Ketepatan indeks yang dimasukkan disemak, dan kemudian di dalam kaedah, elemen tidak dipadam sepenuhnya, tetapi kaedah peribadi dipanggil fastRemove(Object[] es, int i), di mana pemadaman sudah berlaku. Kami menghantar tatasusunan kami dan indeks yang ditentukan kepada kaedah sebagai input. Elemen disalin menggunakan System.arraycopy(), saiz tatasusunan dikurangkan, dan kemudian kami menetapkan null kepada elemen terakhir. Perlu diingat bahawa tatasusunan baharu tidak dibuat: System.arraycopy(es, i + 1, es, i, size - 1 - i); Bahagian yang berada di sebelah kanan kedudukan di bawah indeks yang ditentukan (i+1) disalin ke dalam tatasusunan asal kami (es), dan ia terletak bermula dari kedudukan yang sangat. (i) di mana elemen itu terletak untuk dipadamkan. Oleh itu, kami melakukan anjakan ke kiri dan memadamkan elemen kami. Mari cuba alih keluar elemen pada indeks 3 daripada tatasusunan di bawah: Mari kita pertimbangkan versi kedua kaedah:

public boolean remove(Object o)

Kaedah mengalih keluar elemen yang diluluskan daripada senarai o, atau lebih tepat lagi, objek pada pautan yang ditentukan. Jika unsur hadir dalam senarai, ia dialih keluar dan semua elemen dialihkan ke kiri. Jika elemen wujud dalam senarai dan berjaya dialih keluar, kaedah itu akan mengembalikan benar; jika tidak, palsu. Sama seperti pilihan dengan pemadaman mengikut indeks, kaedah ini dipanggil fastRemove(), di mana tindakan yang sama berlaku. Perbezaannya ialah kaedah itu remove(Object o)juga mencari objek yang dikehendaki melalui kaedah equals()kelas Objek. Apabila mengalih keluar mengikut nilai, gelung akan melalui semua elemen senarai sehingga padanan ditemui. Hanya elemen pertama yang ditemui akan dipadamkan. Mari kita ringkaskan: apabila memadamkan elemen daripada tatasusunan dinamik, tiada lubang yang tinggal seperti dalam tatasusunan biasa (sel yang dipadamkan tidak akan kosong). Semua elemen berikutnya (yang berada di sebelah kanan indeks) dialihkan satu kedudukan ke kiri. Terdapat beberapa kaedah tambahan yang boleh digunakan untuk mengalih keluar elemen daripada senarai kepada tahap yang berbeza-beza. Mari kita lihat mereka secara ringkas. Membersihkan koleksi kami:

public void clear()

Satu gelung mudah forberulang melalui semua elemen tatasusunan, memberikan null kepada setiap elemen. Anda boleh mengalih keluar elemen tersebut daripada koleksi kami yang terkandung dalam koleksi lain yang dipindahkan seperti ini:

public boolean removeAll(Collection< ?> c)

Jika anda perlu mengalih keluar beberapa elemen, anda mungkin tidak sepatutnya melakukannya dalam gelung bersyarat: kaedah ini lebih mudah dan selamat removeAll(). Ia menerima koleksi elemen yang akan dialih keluar daripada senarai. Koleksi mesti mengandungi unsur-unsur jenis yang sama yang disimpan oleh senarai sasaran. Jika tidak ia akan dibuang ClassCastException. Kaedah akan kembali benar jika senarai telah diubah hasil daripada panggilan kaedah. Mengalih keluar elemen yang bukan milik koleksi yang diluluskan:

public boolean retainAll(Collection< ?> c)

Katakan kami 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 selepas listSecond.retainAll(listFirst)dalam listSecondakan kekal:

"White"
"Red"

Memandangkan "Hijau" telah dialih keluar, yang tiada dalam listFirst. Tetapi selepas listSecond.removeAll(listFirst)itu ia listSecondakan kekal:

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

Tidak tergolong dalam koleksi yang diluluskan - bermakna jika terdapat elemen yang tidak ada dalam koleksi yang diluluskan, maka anda perlu mengeluarkannya daripada yang pertama (yang kaedah itu digunakan). Kepunyaan koleksi yang dipindahkan - sewajarnya, jika terdapat unsur dalam kedua-dua koleksi pertama dan kedua (dipindahkan), maka pendua dari yang pertama dimusnahkan.

protected void removeRange(int fromIndex, int toIndex)

Mengalih keluar daripada senarai semua elemen yang berada di antara indeks yang ditentukan permulaan (inklusif) dan indeks yang ditentukan berakhir (tidak termasuk). Perlu diingat bahawa kaedah itu tidak boleh dipanggil terus pada objek ArrayList. Untuk menggunakannya anda perlu mewarisi daripada AbstractList/ArrayList. Kaedah ini juga digunakan oleh kaedah lain (subList, yang akan dibincangkan kemudian).

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

Mengalih keluar elemen daripada koleksi berdasarkan predikat yang diberikan. Predikat itu sendiri ialah fungsi/algoritma/keadaan tertentu berdasarkan satu atau lebih elemen yang sepadan dengan keadaan tertentu akan dialih keluar. Predicate— antara muka berfungsi (hanya mengandungi satu kaedah, jadi ia boleh digunakan sebagai lambda), berfungsi berdasarkan prinsip "menerima satu parameter - boolean dikembalikan". Pada asasnya, kaedah tersebut mengatasi pelaksanaan daripada antara muka Collectiondan melaksanakan "strategi" berikut: ia melelang melalui elemen dan menandakan yang sepadan dengan Predicate; ia kemudian dijalankan untuk kali kedua untuk mengalih keluar (dan mengalihkan) elemen yang ditanda dalam lelaran pertama. Mari kita laksanakan antara muka Predicateyang akan mengembalikan benar jika dua objek adalah sama:

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

Dalam kelas lain, mari kita buat ArrayList dari Stringdan objek kelas kita yang melaksanakan Predicate:

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

varc1Mari tulis nilai "Putih" kepada pembolehubah :

filter.varc1 = "White";

Mari tambahkan beberapa baris pada senarai:

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 laksanakan kaedah pada list removeIf, yang mana kita akan lulus objek kita dengan syarat:

color_list.removeIf(filter);

Akibatnya, semua baris dengan nilai "Putih" akan dialih keluar daripada senarai, kerana "predikat" kami membandingkannya untuk kesamarataan. Senarai akhir: [Hitam, Merah, Kuning]. Menggantikan elemen

public E set(int index, E element)

Menggantikan elemen pada kedudukan yang ditentukan indexdengan yang diluluskan element. Indeks juga mestilah lebih besar daripada sifar dan kurang daripada indeks elemen terakhir, jika tidak pengecualian akan dilemparkan IndexOutOfBoundsException. Tiada salinan tatasusunan dalaman berlaku. Secara mudah, bukannya elemen pada indeks yang ditentukan, elemen baharu dimasukkan, i.e. timpa nilai.

public void replaceAll(UnaryOperator<e> operator)

Menukar semua elemen koleksi (mungkin dengan syarat). Selalunya digunakan dalam kombinasi dengan lambdas atau kelas tanpa nama (tetapi untuk kejelasan, dalam contoh kita hanya akan menggunakan kelas yang melaksanakan antara muka) yang melaksanakan antara muka UnaryOperatordan mentakrifkan kaedahnya. Mari kita laksanakan antara muka:

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

Dalam kelas lain, mari kita buat ArrayList dari Stringdan objek kelas kita yang melaksanakan UnaryOperator:

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

varc1Mari tulis nilai "Putih" kepada pembolehubah :

operator.varc1 = "White";

Mari tambahkan beberapa baris pada senarai:

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 laksanakan kaedah pada senarai replaceAllyang akan kita luluskan objek kita operator:

color_list.replaceAll(operator);

Akibatnya, semua nilai dalam senarai telah digantikan dengan "Putih": [Putih, Putih, Putih, Putih, Putih, Putih]. Dan beginilah, sebagai contoh, anda boleh mengalih keluar semua ruang daripada rentetan yang terdapat dalam koleksi:

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

Kaedah lain: Anda boleh menukar tatasusunan senarai ArrayList kepada tatasusunan biasa menggunakan kaedah:

public Object[] toArray()

atau

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

- di sini jenis tatasusunan yang dikembalikan ditentukan dalam runtime Kaedah ini akan membenarkan:

1. mempercepatkan beberapa operasi;
2. lulus tatasusunan sebagai parameter kepada kaedah yang tidak terlebih beban untuk menerima koleksi secara langsung;
3. Mengintegrasikan kod berasaskan koleksi baharu dengan kod warisan yang tidak mengenali koleksi.

Kembalikan objek salinan tatasusunan:

public Object clone()

Sila ambil perhatian bahawa kaedah clone()mengembalikan jenis Objek, jadi selepas memanggilnya anda perlu menghantar ke kelas yang diperlukan. Pengklonan mencipta objek bebas baharu. Semak koleksi untuk kehadiran objek:

public boolean contains(Object o)

Menyemak kehadiran objek dalam senarai (secara dalaman menggunakan kaedah sama dengan kelas Objek, iaitu membandingkan rujukan), mengembalikan benar/salah bergantung pada hasilnya. Sebagai tambahan kepada gelung biasa, anda boleh lelaran melalui (mengakses setiap elemen, serta melakukan beberapa tindakan) koleksi menggunakan:

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

Inilah cara kami boleh memaparkan senarai kami:

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

Tanpa menggunakan lambdas anda perlu menggunakan kelas tanpa nama dan mengatasi kaedah acceptantara muka Consumer:

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

Dapatkan elemen dengan indeksnya:

public E get(int index)

Digunakan untuk akses rawak kepada elemen koleksi. Mengembalikan elemen yang terletak dalam senarai pada indeks yang ditentukan. Jika index < 0atau ialah index >=bilangan maksimum elemen dalam senarai, pengecualian akan dilemparkan IndexOutOfBoundsException. Ini ialah kaedah asas untuk mendapatkan semula elemen daripada senarai, dan masa untuk mendapatkan semula elemen mengikut indeks akan sentiasa sama, tanpa mengira saiz ArrayList, kerana ia mengakses sel tatasusunan tertentu. Mencari indeks untuk objek tertentu:

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

Kaedah mengembalikan indeks unsur pertama (apabila objek yang diberikan pertama kali ditemui) atau kejadian terakhir (apabila objek yang diberikan kali terakhir ditemui) elemen dalam senarai. Jika elemen tidak wujud dalam senarai, kaedah akan kembali -1. Semak koleksi untuk elemen:

public boolean isEmpty();

Kaedah mengembalikan benar jika senarai kosong (kelihatan untuk melihat sama ada medan adalah sama size 0), jika tidak palsu. Jika senarai mengandungi hanya unsur nol, kaedah akan mengembalikan palsu. Dalam erti kata lain, unsur nol juga diambil kira oleh kaedah ini. Ketahui bilangan elemen dalam senarai:

public int size();

Mengembalikan bilangan elemen dalam senarai (nilai medan saiz). Bilangan elemen mungkin berbeza daripada kapasiti senarai (kapasiti). Dapatkan iterator untuk senarai:

public Iterator< E> iterator();

Mengembalikan iterator untuk senarai untuk kegunaan kemudian dalam gelung atau sebarang pemprosesan lain. Peulang melaksanakan tingkah laku gagal-cepat. Jika ia berjalan melalui koleksi dan melihat beberapa pengubahsuaian padanya (yang tidak diperoleh menggunakan kaedah iterator), ia segera membuang pengecualian ConcurrentModificationException. Iterator mempunyai sesuatu yang dipanggil modification count. Apabila lelaran melelang melalui koleksi selepas setiap next/hasNext/remove, ia menyemak kaunter ini. Jika ia tidak sepadan dengan apa yang dijangkakan oleh iterator, ia akan mengeluarkan pengecualian. Saya tidak akan mempertimbangkan iterator secara terperinci di sini.

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

Mengembalikan lelaran senarai untuk senarai untuk kegunaan kemudian dalam gelung atau sebarang pemprosesan lain. Antara muka ListIteratormemanjangkan antara muka Iteratoruntuk laluan dua hala senarai dan pengubahsuaian elemennya. Dalam versi yang terlebih beban, anda boleh melepasi indeks dari mana "perjalanan" akan bermula. Indeks dalam kes ini menandakan elemen pertama dari mana kaedah akan memulakan kerjanya next(), dan apabila kaedah dipanggil, previous()traversal akan bermula dari elemen di bawah indeks "lulus indeks - 1".

public Spliterator <E> spliterator()

Java 8 memperkenalkan jenis lelaran pengikatan lewat dan cepat gagal yang dipanggil lelaran pembatas. Iterator pemisah membolehkan anda mengulangi jujukan elemen, tetapi ia digunakan dengan cara yang berbeza. Ciri terpenting antara muka Spliterator ialah keupayaannya untuk menyokong lelaran selari bagi bahagian individu bagi jujukan unsur, dan oleh itu pengaturcaraan selari.