Hai! Dalam pelajaran sebelumnya, kita mendalami array dan meninjau contoh umum bekerja dengan array. Dalam pelajaran ini, kita akan meninjau lebih dekat di Java ArrayList. Secara umum, array sangat berguna. Dan, seperti yang telah Anda ketahui, Anda dapat melakukan banyak hal dengannya :) Tetapi array memang memiliki sejumlah kekurangan.
Ukuran terbatas. Anda perlu mengetahui berapa banyak elemen yang perlu ditampung oleh array Anda pada saat Anda membuatnya. Jika Anda meremehkan, maka Anda tidak akan memiliki cukup ruang. Melebihi, dan array akan tetap setengah kosong, yang juga buruk. Lagi pula, Anda masih mengalokasikan lebih banyak memori daripada yang diperlukan.
Array tidak memiliki metode untuk menambahkan elemen. Anda harus selalu secara eksplisit menunjukkan indeks posisi di mana Anda ingin menambahkan elemen. Jika Anda secara tidak sengaja menentukan indeks untuk posisi yang ditempati oleh beberapa nilai yang Anda butuhkan, itu akan ditimpa.
Tidak ada metode untuk menghapus item. Suatu nilai hanya dapat "dinolkan".
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("Behemoth");
cats[2] = new Cat("Lionel Messi");
cats[1] = null;
System.out.println(Arrays.toString(cats));
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
}
Keluaran: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Untungnya, pencipta Java sangat menyadari kelebihan dan kekurangan array, dan karena itu menciptakan struktur data yang sangat menarik bernama Java ArrayList . Berbicara sesederhana mungkin, sebuah Java ArrayList adalah array yang "diperkuat" dengan banyak fitur baru.
Cara Membuat ArrayList
Sangat mudah untuk membuat:
ArrayList<Cat> cats = new ArrayList<Cat>();
Sekarang kami telah membuat daftar untuk menyimpan objek Cat . Perhatikan bahwa kami tidak menentukan ukuran ArrayList , karena dapat diperluas secara otomatis. Bagaimana ini mungkin? Sebenarnya cukup sederhana. Ini mungkin mengejutkan Anda, tetapi ArrayList di Java dibangun di atas array yang sangat biasa :) Ya, ini berisi array, dan di situlah elemen kami disimpan. Tapi ArrayList di Java memiliki cara khusus untuk bekerja dengan array tersebut:
Saat array internal diisi, ArrayList membuat array baru secara internal. Ukuran array baru adalah ukuran array lama dikalikan 1,5 ditambah 1.
Semua data disalin dari array lama ke yang baru
Array lama dibersihkan oleh pengumpul sampah.
Mekanisme ini memungkinkan Java ArrayList (tidak seperti array biasa) untuk mengimplementasikan metode untuk menambahkan elemen baru. Itu add()metodenya
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<Cat>();
cats.add(new Cat("Behemoth"));
}
Item baru ditambahkan ke akhir daftar. Sekarang tidak ada risiko meluapnya array, jadi metode ini benar-benar aman. Omong-omong, ArrayList tidak hanya dapat menemukan objek berdasarkan indeksnya, tetapi juga sebaliknya: ia dapat menggunakan referensi untuk menemukan indeks objek di ArrayList ! Inilah gunanya metode indexOf() : Kita meneruskan referensi ke objek yang kita inginkan, dan indexOf() mengembalikan indeksnya:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
int thomasIndex = cats.indexOf(thomas);
System.out.println(thomasIndex);
}
Keluaran: 0 Benar. Objek thomas kita memang tersimpan di elemen 0. Array tidak hanya memiliki kekurangan. Mereka juga memiliki keunggulan yang tidak diragukan lagi. Salah satunya adalah kemampuan untuk mencari elemen berdasarkan indeks. Karena kami menunjuk ke sebuah indeks, yaitu ke alamat memori tertentu, mencari array dengan cara ini sangat cepat. ArrayListtahu bagaimana melakukannya juga! Metode get() mengimplementasikan ini:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
Cat secondCat = cats.get(1);
System.out.println(secondCat);
}
Output: Cat{name='Behemoth'} Selain itu, Anda dapat dengan mudah mengetahui apakah ArrayList berisi objek tertentu. Ini dilakukan dengan menggunakan metode ArrayList contains() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
cats.remove(fluffy);
System.out.println(cats.contains(fluffy));
}
Metode memeriksa apakah larik internal ArrayList berisi elemen, dan mengembalikan boolean (benar atau salah). Output: false Dan hal penting lainnya tentang penyisipan. ArrayList memungkinkan Anda menggunakan indeks untuk menyisipkan elemen tidak hanya di akhir array, tetapi di mana saja. Ini memiliki dua metode untuk ini:
ArrayList tambahkan (indeks int, elemen Cat)
Set ArrayList (indeks int, elemen Cat)
Sebagai argumen, kedua metode ini mengambil indeks posisi yang ingin Anda sisipkan, dan referensi ke objek itu sendiri. Perbedaannya adalah memasukkan menggunakan set() akan menimpa nilai lama. Memasukkan menggunakan add() pertama-tama menggeser semua elemen dari [indeks] ke akhir array, dan kemudian menambahkan objek yang ditentukan di posisi kosong yang dihasilkan.
Berikut contohnya:
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
System.out.println(cats.toString());
cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set
System.out.println(cats.toString());
}
Keluaran: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] Kami memiliki daftar 2 kucing . Kemudian kami memasukkan satu lagi sebagai elemen 0 menggunakan metode set() . Akibatnya, elemen lama diganti dengan yang baru.
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
System.out.println(cats.toString());
cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add
System.out.println(cats.toString());
}
Dan di sini kita melihat bahwa add() bekerja secara berbeda. Itu memindahkan semua elemen ke kanan dan kemudian menulis nilai baru sebagai elemen 0. Output: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] Untuk menghapus daftar sepenuhnya, kami menggunakan metode clear() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
cats.clear();
System.out.println(cats.toString());
}
Keluaran: [] Semuanya telah dihapus dari daftar. Omong-omong, harap perhatikan: tidak seperti array, ArrayList menimpa metode toString() dan sudah menampilkan daftar dengan tepat sebagai string. Dengan array biasa, kami harus menggunakan kelas Arrays untuk ini. Dan karena saya menyebutkan Arrays : Java memungkinkan Anda dengan mudah "beralih" antara array dan ArrayList , yaitu mengonversi satu ke yang lain. Kelas Arrays memiliki metode Arrays.asList() untuk ini. Kami menggunakannya untuk mendapatkan konten sebagai array dan meneruskannya ke konstruktor ArrayList kami :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
Cat[] catsArray = {thomas, behemoth, lionel, fluffy};
ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
System.out.println(catsList);
}
Output: [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] Anda juga bisa pergi ke arah yang berlawanan: dapatkan array dari objek ArrayList . Kami melakukan ini menggunakan metode toArray() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
Cat[] catsArray = cats.toArray(new Cat[0]);
System.out.println(Arrays.toString(catsArray));
}
Catatan: kita melewatkan array kosong ke metode toArray() . Ini bukan sebuah kesalahan. Di dalam kelas ArrayList , metode ini diimplementasikan sedemikian rupa sehingga melewatkan array kosong akan meningkatkan kinerjanya. Ingatlah hal ini untuk masa depan (tentu saja, Anda dapat melewatkan array dengan ukuran tertentu; itu juga akan berfungsi). Oh, tentang ukurannya. Ukuran daftar saat ini dapat ditemukan menggunakan metode size() :
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<>();
Cat thomas = new Cat("Thomas");
Cat behemoth = new Cat("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.size());
}
Penting untuk dipahami bahwa tidak seperti properti panjang array , metode ArrayList.size() mengembalikan jumlah elemen sebenarnya, bukan kapasitas aslinya. Lagi pula, kami tidak menentukan ukuran saat membuat ArrayList . Namun, Anda dapat menentukannya — ArrayList memiliki konstruktor yang sesuai. Namun dalam hal menambahkan elemen baru, ini tidak mengubah perilakunya:
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("Behemoth");
Cat lionel = new Cat("Lionel Messi");
Cat fluffy = new Cat ("Fluffy");
cats.add(thomas);
cats.add(behemoth);
cats.add(lionel);
cats.add(fluffy);
System.out.println(cats.size());
}
Keluaran konsol: 4 Kami telah membuat daftar 2 elemen, tetapi diam-diam diperluas saat kami membutuhkannya. Pertimbangan lain adalah jika kita membuat daftar yang sangat kecil pada awalnya, daftar itu harus diperluas lebih sering, yang akan menggunakan beberapa sumber daya. Kami hampir tidak menyentuh proses menghapus elemen dari ArrayList dalam pelajaran ini. Tentu saja, ini bukan karena hal itu luput dari pikiran kami. Kami telah memasukkan topik ini ke dalam pelajaran terpisah yang akan Anda temui nanti :) Untuk memperkuat apa yang Anda pelajari, kami sarankan Anda menonton video pelajaran dari Kursus Java kami
GO TO FULL VERSION