Kelas ArrayList dalam Java

hello! Dalam kuliah sebelumnya, kami meneliti secara terperinci struktur data seperti tatasusunan dan melihat contoh biasa bekerja dengannya. Tetapi struktur data ini mempunyai beberapa kelemahan. Jawapan kepada mereka di Jawa ialah kemunculan ArrayList. Untuk meletakkannya semudah mungkin, ArrayList dalam Java ialah tatasusunan "dinaik taraf" dengan banyak ciri baharu.

Bagaimanakah Java Arraylist berbeza daripada tatasusunan biasa?

Secara amnya, tatasusunan agak mudah dan, seperti yang telah anda perhatikan, anda boleh melakukan banyak perkara dengannya :) Walau bagaimanapun, tatasusunan juga mempunyai beberapa kelemahan.

• Saiz terhad. Anda perlu tahu sudah pada peringkat mencipta tatasusunan berapa banyak sel yang sepatutnya terkandung. Jika anda meremehkan jumlah yang diperlukan, ruang tidak akan mencukupi. Jika anda menilai terlalu tinggi, tatasusunan akan kekal separuh kosong, dan itu tidak begitu teruk. Lagipun, ternyata anda juga akan memperuntukkan lebih banyak memori untuknya daripada yang diperlukan.
• Tatasusunan tidak mempunyai kaedah untuk menambah elemen. Anda sentiasa perlu menyatakan secara eksplisit indeks sel di mana anda ingin menambah elemen. Jika anda secara tidak sengaja menentukan sel yang sudah diduduki dengan beberapa nilai yang diingini, ia akan ditimpa.
• Tiada kaedah untuk mengalih keluar elemen. Nilai hanya boleh "disifarkan".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Hippopotamus");
       cats[2] = new Cat("Philip Markovich");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Kesimpulan:

[Cat{name='Томас'}, null, Cat{name='Фorпп Маркович'}]

Semua kekurangan ini boleh dihapuskan menggunakan ArrayList. Ia dicipta dengan sangat mudah:

ArrayList<Cat> cats = new ArrayList<Cat>();

Kini kami telah mencipta senarai untuk menyimpan objek Cat. Beri perhatian:kami tidak menyatakan saiz ArrayList kerana ia boleh dikembangkan secara automatik. Bagaimana ini boleh berlaku? Dengan mudah. Anda akan terkejut, tetapi ArrayList adalah berdasarkan tatasusunan biasa :) Ya, di dalamnya terdapat tatasusunan di mana elemen kami disimpan. Tetapi ArrayList mempunyai mekanisme khas untuk bekerja dengannya:

• Apabila tatasusunan dalaman ini penuh, ArrayList mencipta tatasusunan baharu dalam dirinya sendiri. Saiznya = (saiz tatasusunan lama * 1.5) +1.
• Semua data disalin daripada tatasusunan lama kepada yang baharu
• Susunan lama dikeluarkan oleh pemungut sampah.

Terima kasih kepada mekanisme ini, ArrayList (berbanding dengan tatasusunan) melaksanakan kaedah untuk menambah elemen baharu. Ini adalah kaedah add().

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Hippopotamus"));
}

Elemen baharu ditambahkan pada penghujung senarai. Kini tiada risiko limpahan, jadi mekanisme ini benar-benar selamat. Dengan cara ini, ArrayList bukan sahaja boleh mencari objek mengikut indeks, tetapi juga sebaliknya - ia boleh mencari indeks objek dalam ArrayList dengan merujuk kepada objek! Untuk melakukan ini, ia melaksanakan kaedah indexOf(): Kami menghantar ke dalamnya pautan ke objek yang diingini, dan indexOf()ia mengembalikan indeksnya kepada kami:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Kesimpulan:

0

Betul, objek thomassebenarnya disimpan dalam sel 0. Array bukan sahaja mempunyai kelemahan, tetapi juga kelebihan yang tidak diragukan lagi. Salah satunya ialah mencari elemen mengikut indeks. Memandangkan kita menunjuk ke indeks, iaitu, ke alamat tertentu dalam ingatan, carian tatasusunan sedemikian adalah sangat pantas. ArrayList di Java boleh melakukan ini juga! Untuk melakukan ini, ia melaksanakan kaedah get():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Kesimpulan:

Cat{name='Бегемот'}

Selain itu, anda boleh mengetahui dengan mudah sama ada ArrayList mengandungi objek tertentu atau tidak. Ini dilakukan menggunakan kaedah contains():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.remove(pushok);
   System.out.println(cats.contains(pushok));
}

Kaedah menyemak sama ada elemen itu terkandung dalam tatasusunan dalaman ArrayList dan mengembalikan hasilnya dalam bentuk boolean- trueatau false. Kesimpulan:

false

Dan satu lagi perkara penting tentang sisipan. ArrayList membolehkan anda memasukkan data bukan sahaja pada penghujung tatasusunan, tetapi juga ke dalam mana-mana sel mengikut indeks. Ia mempunyai dua kaedah untuk ini:

• add(int index, Cat element)
• set(int index, Cat element)

Kepada kedua-duanya, anda lulus indeks sel yang anda ingin masukkan, dan pautan ke objek itu sendiri. Perbezaannya ialah menampal melalui set()menimpa nilai lama yang disimpan dalam sel. Dan memasukkan melalui add()anjakan pertama semua elemen bermula dari [index]ke penghujung tatasusunan, dan menambah objek yang anda perlukan ke sel kosong yang terhasil. Berikut ialah contoh:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, philipp);//Now we have a list of 2 cats. We add the 3rd via set:

   System.out.println(cats.toString());
}

Kesimpulan:

[[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Бегемот'}]

Kami mempunyai senarai 2 kucing, kami memasukkan satu lagi melalui kaedah set()ke dalam sel 0. Akibatnya, nilai lama yang disimpan dalam sel ini telah digantikan dengan yang baru.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, philipp);//Now we have a list of 2 cats. Add the 3rd via add

   System.out.println(cats.toString());
}

Tetapi ia add()berfungsi secara berbeza. Dia mengalihkan semua elemen ke kanan dan kemudian menulis nilai baharu ke dalam sel 0. Kesimpulan:

[Cat{name='Томас'}, Cat{name='Бегемот'}]
[Cat{name='Фorпп Маркович'}, Cat{name='Томас'}, Cat{name='Бегемот'}]

Untuk mengosongkan senarai sepenuhnya, gunakan kaedah clear():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   cats.clear();

   System.out.println(cats.toString());
}

Kesimpulan:

[]

Semua kandungan telah dialih keluar daripada senarai. Dengan cara ini, beri perhatian: tidak seperti tatasusunan, dalam ArrayList kaedah toString() ditindih dan serta-merta memaparkan senarai dalam format rentetan. Dalam kes tatasusunan, kami terpaksa menggunakan kelas Tatasusunan untuk ini. Dan kerana kita teringat Arrays: di Java anda boleh dengan mudah "bertukar" antara array dan ArrayList, iaitu, menukar satu kepada yang lain. Kelas Arrays mempunyai kaedah untuk ini, Arrays.asList(). Dengan bantuannya, kami mendapat kandungan tatasusunan sebagai senarai dan menyerahkannya kepada pembina ArrayList kami:

public static void main(String[] args) {

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   Cat[] catsArray = {thomas, behemoth, philipp, pushok};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Kesimpulan:

[Cat{name='Томас'}, Cat{name='Бегемот'}, Cat{name='Фorпп Маркович'}, Cat{name='Пушок'}]

Anda boleh melakukan sebaliknya - dapatkan tatasusunan daripada objek ArrayList. Untuk melakukan ini, gunakan kaedah toArray():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Sila ambil perhatian: kami menghantar tatasusunan kosong kepada kaedah toArray(). Ia bukan satu kesilapan. Di dalam kelas ArrayList, kaedah ini dilaksanakan dengan cara yang melepasi tatasusunan kosong meningkatkan prestasinya. Buat masa ini, hanya ingat ini untuk masa hadapan (tetapi anda juga boleh memindahkan saiz tertentu, ia akan berfungsi). Bercakap tentang saiz. Saiz semasa senarai boleh didapati menggunakan kaedah size():

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Adalah penting untuk memahami di sini bahawa, tidak seperti lengthsifat tatasusunan, kaedah ArrayList.size() mengembalikan dengan tepat bilangan elemen, dan bukan kapasiti awal, kerana kami tidak menyatakannya semasa mencipta ArrayList. Dengan cara ini, secara amnya mungkin untuk menunjukkannya. ArrayList mempunyai pembina yang sepadan. Tetapi kelakuannya dari segi menambah elemen baharu tidak akan berubah:

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);//create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Hippopotamus");
   Cat philipp = new Cat("Philip Markovich");
   Cat pushok = new Cat("Fluff");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(philipp);
   cats.add(pushok);

   System.out.println(cats.size());
}

Output konsol:

4

Kami mencipta senarai dengan 2 elemen, tetapi apabila kami memerlukannya, ia mudah berkembang. Perkara lain ialah jika kita pada mulanya mencipta senarai yang sangat kecil, ia perlu menjalankan operasi pengembangan lebih kerap, dan ini menggunakan sejumlah sumber. Dalam kuliah ini, kami hampir tidak menyentuh proses mengalih keluar elemen daripada ArrayList. Sudah tentu, ini bukan disebabkan oleh kealpaan. Topik ini telah diasingkan menjadi kuliah yang berasingan, yang boleh anda baca lebih lanjut :)