ArrayList dalam gambar

Hai! Pelajaran hari ini tentang ArrayListakan lebih mudah dan lebih sulit dari pelajaran sebelumnya. Ini akan lebih sulit karena hari ini kita akan melihat ArrayListdan mempelajari apa yang terjadi selama berbagai operasi. Di sisi lain, pelajaran ini hampir tidak memiliki kode. Sebagian besar gambar dan penjelasan. Baiklah, ayo :) Seperti yang sudah Anda ketahui, ArrayListmemiliki array biasa di dalamnya, yang berfungsi sebagai penyimpan data. Dalam kebanyakan kasus, kami tidak menentukan ukuran daftar yang tepat. Tetapi array internal harus memiliki ukuran tertentu! Dan begitulah. Ukuran standarnya adalah 10 .

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
}

Pertama, mari kita lihat seperti apa menambahkan elemen baru. Urutan pertama bisnis adalah untuk memeriksa apakah larik internal memiliki cukup ruang dalam larik internal dan apakah satu elemen lagi akan cocok. Jika ada ruang, elemen baru ditambahkan ke akhir daftar. Ketika kami mengatakan "sampai akhir", kami tidak bermaksud posisi terakhir dalam array (itu akan menjadi aneh). Yang kami maksud adalah posisi mengikuti elemen arus terakhir. Indeksnya adalah cars.size(). Daftar kami saat ini kosong ( cars.size() == 0). Dengan demikian, elemen baru akan ditambahkan pada posisi 0.

ArrayList<Car> cars = new ArrayList<>();
Car ferrari = new Car("Ferrari 360 Spider");
cars.add(ferrari);

Itu cukup jelas. Apa yang terjadi jika kita sisipkan di tengah, yaitu di antara elemen lainnya?

public static void main(String[] args) {
   ArrayList<Car> cars = new ArrayList<>();
   Car ferrari = new Car("Ferrari 360 Spider");
   Car bugatti = new Car("Bugatti Veyron");
   Car lambo = new Car("Lamborghini Diablo");
   Car ford = new Car("Ford Modneo");
  
   cars.add(ferrari);
   cars.add(bugatti);
   cars.add(lambo);
  
   cars.add(1, ford);// add ford to cell 1, which is already occupied
}

Sekali lagi, pertama ada pemeriksaan apakah ada cukup ruang di dalam array. Jika ada cukup ruang, maka elemen digeser ke kanan , dimulai dari posisi di mana kita memasukkan elemen baru. Kita menyisipkan pada posisi 1. Dengan kata lain, elemen dari posisi 3 disalin ke posisi 4, elemen 2 ke posisi 3, dan elemen 1 ke posisi 2. Kemudian elemen baru kita disisipkan pada tempatnya. Elemen sebelumnya (bugatti) telah disalin dari sana ke posisi baru. Sekarang mari kita lihat bagaimana proses ini terjadi jika tidak ada tempat untuk memasukkan elemen baru ke dalam array. Biasanya, pertama-tama ada pemeriksaan untuk melihat apakah ada cukup ruang. Jika tidak ada cukup ruang, maka array baru akan dibuat di dalamArrayListyang ukurannya adalah ukuran array lama dikalikan 1,5 ditambah 1 Dalam kasus kita, ukuran array baru adalah 16. Semua elemen saat ini akan segera disalin ke sana. Array lama akan dihapus oleh pengumpul sampah, dan hanya array baru yang diperluas yang akan tersisa. Sekarang ada ruang untuk elemen baru. Kami memasukkannya di posisi 3, yang ditempati. Sekarang prosedur yang biasa dimulai. Semua elemen, dimulai dengan indeks 3, digeser satu posisi ke kanan, dan elemen baru ditambahkan secara diam-diam. Dan penyisipan selesai! Dan kita selesai dengan penyisipan. Sekarang mari kita bicara tentang menghapus item . Anda akan ingat bahwa kita mengalami masalah saat bekerja dengan array: menghapus elemen membuat "lubang" dalam array.dengan setiap penghapusan, dan kami harus menulis kode kami sendiri setiap kali melakukan perubahan ini. ArrayList mengikuti prinsip yang sama, tetapi sudah mengimplementasikan mekanisme ini. Begini tampilannya: Dan pada akhirnya kita mendapatkan apa yang kita inginkan: Elemen lambotelah dihapus. Di sini kami menghapus elemen dari tengah. Jelas, menghapus elemen dari akhir daftar lebih cepat, karena elemen dihapus begitu saja tanpa perlu menggeser yang lainnya. Mari kita bicara lagi sejenak tentang dimensi dari larik internal dan bagaimana susunannya dalam memori. Memperluas array membutuhkan beberapa sumber daya. Oleh karena itu, jangan membuatArrayListdengan ukuran default jika Anda yakin akan memiliki setidaknya 100 elemen. Larik internal harus diperluas 6 kali saat Anda memasukkan elemen ke-100, dan semua elemen harus digeser setiap saat.

• dari 10 elemen menjadi 16
• dari 16 elemen menjadi 25
• dari 25 sampai 38
• dari 38 menjadi 58
• dari 58 menjadi 88
• dari 88 hingga 133 (yaitu ukuran array lama dikalikan 1,5 plus 1)

Seperti yang dapat Anda bayangkan, ini cukup intensif sumber daya. Jadi, jika Anda sudah mengetahui (bahkan kurang lebih) jumlah item yang dibutuhkan, lebih baik membuat daftar dengan array dengan ukuran tertentu:

ArrayList<Car> cars = new ArrayList<>(100);

Sekarang memori untuk array 100 elemen akan dialokasikan sekaligus, membuat array lebih efisien (tidak perlu diperluas). Strategi ini juga memiliki sisi lain. Saat Anda menghapus objek dari ArrayList, ukuran larik internal tidak berkurang secara otomatis. Misalkan kita memiliki ArrayListarray internal yang sepenuhnya penuh dengan 88 elemen: Saat program berjalan, kita menghapus 77 elemen, jadi hanya tersisa 11: Sudahkah Anda menebak apa masalahnya? Anda mengerti, penggunaan memori yang tidak efisien! Kami hanya menggunakan 11 posisi di sini, tetapi kami telah mengalokasikan memori untuk 88 elemen. Itu 8 kali lebih banyak dari yang kita butuhkan! Dalam hal ini, kita dapat mengoptimalkan penggunaan memori kita dengan salah satu ArrayListmetode khusus kelas:trimToSize(). Metode ini "memangkas" panjang larik internal hingga jumlah elemen yang saat ini disimpan di dalamnya. Sekarang kami hanya mengalokasikan memori sebanyak yang kami butuhkan! :)