ArrayList sa mga larawan

Hi! Ang aralin ngayon tungkol sa ArrayListay magiging mas madali at mas mahirap kaysa sa mga nakaraang aralin. Ito ay magiging mas mahirap dahil ngayon ay titingnan natin sa ilalim ng hood ArrayListat pag-aaralan kung ano ang nangyayari sa iba't ibang operasyon. Sa kabilang banda, ang araling ito ay halos walang code. Ito ay halos mga larawan at mga paliwanag. Well, let's go:) Tulad ng alam mo na, ArrayListay may isang ordinaryong array sa loob, na gumaganap bilang isang data store. Sa karamihan ng mga kaso, hindi namin tinukoy ang eksaktong laki ng listahan. Ngunit ang panloob na hanay ay dapat na may ilang sukat! At ganoon din ang ginagawa nito. Ang default na laki nito ay 10 .

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

Una, tingnan natin kung ano ang hitsura ng pagdaragdag ng mga bagong elemento. Ang unang pagkakasunud-sunod ng negosyo ay upang suriin kung ang panloob na hanay ay may sapat na espasyo sa panloob na hanay at kung ang isa pang elemento ay magkasya. Kung may puwang, pagkatapos ay idaragdag ang bagong elemento sa dulo ng listahan. Kapag sinabi naming "hanggang sa dulo", hindi namin ibig sabihin ang huling posisyon sa array (na magiging kakaiba). Ang ibig naming sabihin ay ang posisyon na sumusunod sa huling kasalukuyang elemento. Ang index nito ay cars.size(). Ang aming listahan ay kasalukuyang walang laman ( cars.size() == 0). Alinsunod dito, ang bagong elemento ay idaragdag sa posisyon 0.

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

Iyan ay sapat na malinaw. Ano ang mangyayari kung ipasok natin sa gitna, ibig sabihin, sa pagitan ng iba pang mga elemento?

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
}

Muli, una ay may suriin kung may sapat na espasyo sa array. Kung may sapat na espasyo, ang mga elemento ay ililipat pakanan , simula sa posisyon kung saan namin ilalagay ang bagong elemento. Kami ay naglalagay sa posisyon 1. Sa madaling salita, ang elemento mula sa posisyon 3 ay kinopya sa posisyon 4, elemento 2 sa posisyon 3, at elemento 1 sa posisyon 2. Pagkatapos ay ang aming bagong elemento ay ipinasok sa lugar nito. Ang nakaraang elemento (bugatti) ay nakopya na mula doon sa isang bagong posisyon. Ngayon tingnan natin kung paano nangyayari ang prosesong ito kung walang mga lugar upang magpasok ng mga bagong elemento sa array. Naturally, may unang pagsusuri upang makita kung mayroong sapat na espasyo. Kung walang sapat na espasyo, isang bagong array ang gagawin sa loob ngArrayListna ang laki ay ang laki ng lumang array beses 1.5 plus 1 Sa aming kaso, ang laki ng bagong array ay magiging 16. Ang lahat ng kasalukuyang elemento ay makokopya doon kaagad. Ang lumang array ay tatanggalin ng basurero, at ang bago, pinalawak na array lamang ang mananatili. Ngayon ay may puwang para sa isang bagong elemento. Inilalagay namin ito sa posisyon 3, na inookupahan. Ngayon ang pamilyar na pamamaraan ay nagsisimula. Ang lahat ng mga elemento, simula sa index 3, ay inilipat sa isang posisyon sa kanan, at ang bagong elemento ay tahimik na idinagdag. At ang pagpasok ay tapos na! At tapos na kami sa pagpasok. Ngayon ay pag-usapan natin ang tungkol sa pag-alis ng mga item . Maaalala mo na nagkaroon kami ng problema kapag nagtatrabaho sa mga array: ang pag-alis ng mga elemento ay gumagawa ng "mga butas" sa isang array.sa bawat pag-alis, at kailangan naming magsulat ng sarili naming code sa bawat oras upang maisagawa ang shift na ito. Sinusunod ng ArrayList ang parehong prinsipyo, ngunit ipinapatupad na nito ang mekanismong ito. Ganito ang hitsura nito: At sa huli makuha natin ang gusto natin: Inalis na ang elemento. lamboDito inalis namin ang isang elemento mula sa gitna. Maliwanag, ang pag-alis ng isang elemento mula sa dulo ng listahan ay mas mabilis, dahil ang elemento ay inalis lang nang hindi kailangang ilipat ang lahat ng iba pa. Mag-usap muli tayo saglit tungkol sa mga sukat ng panloob na hanay at kung paano ito nakaayos sa memorya. Ang pagpapalawak ng isang array ay nangangailangan ng ilang mga mapagkukunan. Alinsunod dito, huwag lumikha ng isangArrayListna may default na laki kung sigurado kang magkakaroon ito ng hindi bababa sa 100 elemento. Ang panloob na array ay kailangang palawakin ng 6 na beses sa oras na ipasok mo ang ika-100 elemento, at ang lahat ng mga elemento ay kailangang ilipat sa bawat oras.

• mula 10 elemento hanggang 16
• mula 16 na elemento hanggang 25
• mula 25 hanggang 38
• mula 38 hanggang 58
• mula 58 hanggang 88
• mula 88 hanggang 133 (ibig sabihin, ang laki ng lumang array ay 1.5 plus 1)

Tulad ng maiisip mo, ito ay medyo masinsinang mapagkukunan. Kaya, kung alam mo na (kahit humigit-kumulang) ang kinakailangang bilang ng mga item, mas mahusay na gumawa ng isang listahan na may array ng isang partikular na laki:

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

Ngayon ang memorya para sa isang array ng 100 elemento ay ilalaan nang sabay-sabay, na ginagawang mas mahusay ang array (hindi na ito kailangang palawakin). May flip side din ang diskarteng ito. Kapag nag-alis ka ng mga bagay mula sa isang ArrayList, hindi awtomatikong bumababa ang laki ng panloob na array. Ipagpalagay na mayroon kaming isang ArrayListganap na buong panloob na hanay ng 88 elemento: Habang tumatakbo ang programa, inaalis namin ang 77 elemento, kaya 11 na lang ang natitira: Nahulaan mo na ba kung ano ang problema? Nakuha mo ito, hindi mahusay na paggamit ng memorya! Gumagamit lang kami ng 11 na posisyon dito, ngunit naglaan kami ng memory para sa 88 na elemento. Iyan ay 8 beses na higit pa sa kailangan natin! Sa kasong ito, maaari naming i-optimize ang aming paggamit ng memorya sa isa sa mga ArrayListespesyal na pamamaraan ng klase:trimToSize(). Ang pamamaraang ito ay "pinuputol" ang haba ng panloob na hanay hanggang sa bilang ng mga elemento na kasalukuyang nakaimbak dito. Ngayon ay naglaan lamang kami ng mas maraming memorya hangga't kailangan namin! :)