ArrayList dalam gambar

Hai! Pelajaran hari ini tentang ArrayListakan menjadi lebih mudah dan lebih sukar daripada pelajaran sebelumnya. Ia akan menjadi lebih sukar kerana hari ini kita akan melihat di bawah hud ArrayListdan mengkaji apa yang berlaku semasa pelbagai operasi. Sebaliknya, pelajaran ini hampir tiada kod. Ia kebanyakannya gambar dan penjelasan. Baiklah, mari :) Seperti yang anda sedia maklum, ArrayListmempunyai tatasusunan biasa di dalam, yang bertindak sebagai stor data. Dalam kebanyakan kes, kami tidak menyatakan saiz senarai yang tepat. Tetapi tatasusunan dalaman mesti mempunyai beberapa saiz! Dan begitu juga. Saiz lalainya ialah 10 .

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

Mula-mula, mari lihat rupa penambahan elemen baharu. Urutan pertama perniagaan adalah untuk menyemak sama ada tatasusunan dalaman mempunyai ruang yang mencukupi dalam tatasusunan dalaman dan sama ada satu elemen lagi akan muat. Jika terdapat ruang, maka elemen baharu akan ditambahkan pada penghujung senarai. Apabila kami menyebut "hingga akhir", kami tidak bermaksud kedudukan terakhir dalam tatasusunan (itu akan menjadi pelik). Kami maksudkan kedudukan berikutan elemen semasa yang terakhir. Indeksnya ialah cars.size(). Senarai kami pada masa ini kosong ( cars.size() == 0). Sehubungan itu, elemen baharu akan ditambah pada kedudukan 0.

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

Itu sudah cukup jelas. Apa yang berlaku jika kita memasukkan di tengah, iaitu antara elemen lain?

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, mula-mula ada semak sama ada terdapat ruang yang mencukupi dalam tatasusunan. Jika terdapat ruang yang mencukupi, maka elemen dialihkan ke kanan , bermula dengan kedudukan di mana kita memasukkan elemen baharu. Kami memasukkan pada kedudukan 1. Dalam erti kata lain, elemen dari kedudukan 3 disalin ke kedudukan 4, elemen 2 ke kedudukan 3, dan elemen 1 ke kedudukan 2. Kemudian elemen baharu kami dimasukkan ke tempatnya. Elemen sebelumnya (bugatti) telah pun disalin dari sana ke kedudukan baharu. Sekarang mari kita lihat bagaimana proses ini berlaku jika tiada tempat untuk memasukkan elemen baharu ke dalam tatasusunan. Sememangnya, terdapat pemeriksaan terlebih dahulu untuk melihat sama ada terdapat cukup ruang. Jika tidak ada ruang yang mencukupi, maka tatasusunan baharu akan dibuat di dalamArrayListyang saiznya ialah saiz tatasusunan lama dikali 1.5 tambah 1 Dalam kes kami, saiz tatasusunan baharu ialah 16. Semua elemen semasa akan disalin ke sana serta-merta. Tatasusunan lama akan dipadamkan oleh pemungut sampah, dan hanya tatasusunan baharu yang dikembangkan akan kekal. Kini terdapat ruang untuk elemen baharu. Kami memasukkannya pada kedudukan 3, yang telah diduduki. Sekarang prosedur biasa bermula. Semua elemen, bermula dengan indeks 3, dianjakkan satu kedudukan ke kanan, dan elemen baharu ditambah secara senyap. Dan penyisipan selesai! Dan kita selesai dengan sisipan. Sekarang mari kita bincangkan tentang mengalih keluar item . Anda akan ingat bahawa kami menghadapi masalah semasa bekerja dengan tatasusunan: mengalih keluar elemen membuat "lubang" dalam tatasusunan.dengan setiap pengalihan keluar, dan kami terpaksa menulis kod kami sendiri setiap kali untuk melaksanakan anjakan ini. ArrayList mengikut prinsip yang sama, tetapi ia sudah melaksanakan mekanisme ini. Beginilah rupanya: Dan pada akhirnya kita mendapat apa yang kita mahukan: Elemen lambotelah dialih keluar. Di sini kami mengalih keluar elemen dari tengah. Jelas sekali, mengalih keluar elemen dari penghujung senarai adalah lebih pantas, kerana elemen itu dialih keluar begitu sahaja tanpa perlu mengalihkan semua yang lain. Mari kita bincangkan sebentar lagi tentang dimensi tatasusunan dalaman dan bagaimana ia disusun dalam ingatan. Memperluas tatasusunan memerlukan beberapa sumber. Oleh itu, jangan buat satuArrayListdengan saiz lalai jika anda pasti ia akan mempunyai sekurang-kurangnya 100 elemen. Tatasusunan dalaman perlu dikembangkan 6 kali pada masa anda memasukkan elemen ke-100, dan semua elemen perlu dialihkan setiap kali.

• daripada 10 elemen kepada 16
• daripada 16 elemen kepada 25
• dari 25 hingga 38
• dari 38 hingga 58
• dari 58 hingga 88
• dari 88 hingga 133 (iaitu saiz tatasusunan lama dikali 1.5 tambah 1)

Seperti yang anda boleh bayangkan, ini agak intensif sumber. Jadi, jika anda sudah tahu (walaupun lebih kurang) bilangan item yang diperlukan, lebih baik buat senarai dengan tatasusunan saiz tertentu:

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

Kini memori untuk tatasusunan 100 elemen akan diperuntukkan sekaligus, menjadikan tatasusunan itu lebih cekap (ia tidak perlu dikembangkan). Strategi ini juga mempunyai sisi lain. Apabila anda mengalih keluar objek daripada ArrayList, saiz tatasusunan dalaman tidak berkurangan secara automatik. Katakan kita mempunyai ArrayListtatasusunan dalaman yang penuh dengan 88 elemen: Semasa program berjalan, kita mengeluarkan 77 elemen, jadi hanya tinggal 11: Adakah anda sudah meneka apa masalahnya? Anda faham, penggunaan memori yang tidak cekap! Kami hanya menggunakan 11 kedudukan di sini, tetapi kami telah memperuntukkan memori untuk 88 elemen. Itu 8 kali lebih banyak daripada yang kita perlukan! Dalam kes ini, kami boleh mengoptimumkan penggunaan memori kami dengan salah satu ArrayListkaedah khas kelas:trimToSize(). Kaedah ini "memangkas" panjang tatasusunan dalaman kepada bilangan elemen yang sedang disimpan di dalamnya. Kini kami hanya memperuntukkan seberapa banyak memori yang kami perlukan! :)