Java ArrayList sa mga larawan

Kamusta! Ang lecture ngayon ArrayListay, sa isang banda, mas simple, at sa kabilang banda, mas mahirap kaysa sa mga nauna. Ito ay mas mahirap, dahil ngayon ay titingnan natin ang "sa ilalim ng talukbong" ArrayListat pag-aralan kung ano ang nangyayari dito sa panahon ng mga operasyon. Sa kabilang banda, halos walang code sa lecture na ito - karamihan ay mga larawan at paliwanag. Kaya, tayo na :) Tulad ng alam mo na, sa loob ArrayListng 'a mayroong isang ordinaryong array, na nagsisilbing isang data store. Sa karamihan ng mga kaso, hindi namin tinukoy ang eksaktong sukat ng listahan. Ngunit ang panloob na hanay ay dapat na may ilang sukat! Ito ay totoo. 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 isang bagong elemento. Una sa lahat, ang isang pagsusuri ay ginawa upang makita kung may sapat na espasyo sa panloob na hanay at kung ang isa pang elemento ay magkasya. Kung may espasyo, ang bagong elemento ay idaragdag sa dulo ng listahan. Kapag sinabi naming "hanggang sa dulo", hindi namin ibig sabihin ang huling cell ng array (na magiging kakaiba). Ito ay tumutukoy sa cell sa tabi ng huling kasalukuyang elemento. Ang index nito ay magiging katumbas ng cars.size(). Ang aming listahan ay kasalukuyang walang laman ( cars.size() = 0). Alinsunod dito, isang bagong elemento ang idadagdag sa cell na may index 0.

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

Malinaw ang lahat dito. Ano ang mangyayari kung ang pagpasok ay isinasagawa sa gitna, iyon ay, sa pagitan ng maraming 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);//добавляем ford в ячейку 1, которая уже занята
}

Muli, sinusuri muna nito kung may sapat na espasyo sa array. Kung may sapat na espasyo, ang mga elemento ay inililipat sa kanan simula sa cell kung saan namin ipinapasok ang bagong elemento. Nag-paste kami sa cell na may index 1. Iyon ay, ang elemento mula sa cell 3 ay kinopya sa cell 4, elemento 2 hanggang cell 3, elemento 1 hanggang cell 2. Pagkatapos nito, ang aming bagong elemento ay ilalagay sa lugar. Ang nakaraang elemento ( bugatti) ay nakopya na mula doon sa isang bagong lokasyon. Ngayon, alamin natin kung paano mangyayari ang prosesong ito kung walang puwang para sa pagpasok sa array. Una, siyempre, isang tseke ay ginawa upang makita kung mayroong sapat na espasyo. Kung ito ay lumabas na walang sapat na espasyo, ArrayListisang bagong array ng laki (laki ng OldArray * 1.5) + 1 ay nilikha sa loob ng 'a. Sa aming kaso, ang bagong array ay magkakaroon ng laki ng 16 na mga cell. Ang lahat ng kasalukuyang elemento ay makokopya doon kaagad. Ang lumang array ay tatanggalin ng basurero, at ang bago at pinalawak na lang ang mananatili. Ngayon ay may libreng espasyo para sa bagong elemento. I-paste namin ito sa cell 3, na inookupahan. Ngayon ang pamilyar na pamamaraan ay nagsisimula. Ang lahat ng mga elemento na nagsisimula sa index 3 ay inilipat sa isang cell sa kanan, at isang bagong elemento ay tahimik na idinagdag. At ngayon ang pagpasok ay matagumpay! Inayos namin ang insertion. Ngayon pag-usapan natin ang tungkol sa pag-alis ng mga elemento . Tulad ng naaalala mo, kapag nagtatrabaho sa mga array, nakatagpo kami ng isang problema: nang tinanggal namin ang mga ito, "mga butas" ang nanatili dito. Ang tanging solusyon ay ilipat ang mga elemento sa kaliwa sa tuwing tatanggalin ang mga ito, at kailangan mong isulat ang code para sa shift nang mag-isa. ArrayListgumagana sa parehong prinsipyo, ngunit sa loob nito ang mekanismong ito ay awtomatikong ipinatupad. Ito ang hitsura nito: At sa huli ay makukuha natin ang ninanais na resulta: Ang elemento lamboay matagumpay na natanggal. Dito kami gumawa ng pagtanggal mula sa gitna. Malinaw na ang pagtanggal mula sa dulo ng listahan ay magiging mas mabilis, dahil ang nais na elemento ay aalisin nang hindi inililipat ang lahat ng iba pa. Tingnan natin muli ang laki ng panloob na hanay at ang imbakan nito sa memorya. Ang pagpapalawak ng array ay isang proseso na nangangailangan ng isang tiyak na halaga ng mga mapagkukunan. Samakatuwid, hindi ka dapat gumawa ArrayListgamit ang default na laki kung alam mong sigurado na magkakaroon ito ng hindi bababa sa 100 elemento. Sa oras na maipasok mo ang ika-100 elemento, lalawak ang panloob na array ng 6 na beses , sa bawat oras na ililipat ang lahat ng elemento.

• 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 (ayon sa formula (laki ng Old Array * 1.5) + 1)

Naturally, ito ay medyo mahal sa mga tuntunin ng mga mapagkukunan. Samakatuwid, kung alam mo na ang ilang (hindi bababa sa tinatayang) bilang ng mga naka-imbak na elemento, mas mahusay na agad na lumikha ng isang listahan na may isang hanay ng isang tiyak na laki:

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

Ngayon, ang isang hanay ng 100 elemento ay agad na ilalaan sa memorya, na magiging mas mahusay dahil ang mga mapagkukunan ay hindi masasayang sa pagpapalawak. Mayroon ding kabilang panig ng barya. Kapag ang mga bagay ay inalis mula ArrayListsa panloob na hanay, ang laki ay hindi awtomatikong nababawasan. Halimbawa, mayroon kaming ArrayListpanloob na hanay ng 88 elemento, na ganap na napuno: Sa panahon ng pagpapatakbo ng programa, inaalis namin ang 77 elemento mula dito, at 11 lamang ang natitira dito: Nahulaan mo na ba kung ano ang problema? Hindi mahusay na paggamit ng memorya, siyempre! Gumagamit lamang kami ng 11 na mga cell, habang mayroon kaming memorya na inilaan para sa 88 mga elemento - iyon ay 8 beses na higit pa kaysa sa kailangan namin! Upang maisagawa ang pag-optimize sa kasong ito, maaari kang gumamit ng isang espesyal na paraan ng klase ArrayList- trimToSize(). Ito ay "pinutol" ang haba ng panloob na hanay sa bilang ng mga elemento na kasalukuyang nakaimbak dito. Ngayon mas maraming memorya ang inilalaan kung kinakailangan! :)