Hi! Sa nakaraang mga aralin, gumawa kami ng malalim na pagsisid sa mga array at sinuri namin ang mga karaniwang halimbawa ng pagtatrabaho sa mga array. Sa araling ito, kukuha tayo ng mas malapit na pagsusuri sa Java ArrayList. Sa pangkalahatan, ang mga array ay sobrang madaling gamitin. At, tulad ng napansin mo na, marami kang magagawa sa kanila :) Ngunit ang mga array ay may ilang mga pagkukulang.
Limitadong laki. Kailangan mong malaman kung ilang elemento ang kailangang taglayin ng iyong array sa oras na likhain mo ito. Kung minamaliit mo, hindi ka magkakaroon ng sapat na espasyo. Mag-overestimate, at ang array ay mananatiling kalahating laman, na masama rin. Pagkatapos ng lahat, naglalaan ka pa rin ng mas maraming memorya kaysa sa kinakailangan.
Ang isang array ay walang mga pamamaraan para sa pagdaragdag ng mga elemento. Dapat mong palaging tahasang ipahiwatig ang index ng posisyon kung saan mo gustong magdagdag ng elemento. Kung hindi mo sinasadyang tinukoy ang index para sa isang posisyon na inookupahan ng ilang halaga na kailangan mo, ito ay mapapatungan.
Walang mga paraan para magtanggal ng item. Ang isang halaga ay maaari lamang "i-zero out".
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 + '\'' +
'}';
}
}
Output: [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Sa kabutihang palad, alam ng mga tagalikha ng Java ang mga pakinabang at disadvantage ng arrays, at samakatuwid ay lumikha ng isang napaka-interesante na istruktura ng data na tinatawag na Java ArrayList . Sa pagsasalita nang simple hangga't maaari, ang isang Java ArrayList ay isang "soup up" na hanay na may maraming mga bagong tampok.
Paano Gumawa ng ArrayList
Napakadaling likhain:
ArrayList<Cat> cats = new ArrayList<Cat>();
Ngayon nakagawa na kami ng listahan para sa pag-iimbak ng mga bagay ng Cat . Tandaan na hindi namin tinutukoy ang laki ng ArrayList , dahil maaari itong awtomatikong lumawak. Paano ito posible? Ito ay medyo simple, sa totoo lang. Maaaring sorpresa ka, ngunit ang ArrayList sa Java ay binuo sa ibabaw ng isang napaka-ordinaryong array :) Oo, naglalaman ito ng array, at doon naka-imbak ang aming mga elemento. Ngunit ang ArrayList sa Java ay may espesyal na paraan ng pagtatrabaho sa array na iyon:
Kapag napuno ang panloob na array, ang ArrayList ay gagawa ng bagong array sa loob. Ang laki ng bagong array ay ang laki ng lumang array na 1.5 plus 1.
Ang lahat ng data ay kinopya mula sa lumang array patungo sa bago
Ang lumang hanay ay nililinis ng basurero.
Ang mekanismong ito ay nagpapahintulot sa Java ArrayList (hindi tulad ng isang ordinaryong array) na magpatupad ng isang paraan para sa pagdaragdag ng mga bagong elemento. Ito ang add()pamamaraan
public static void main(String[] args) {
ArrayList<Cat> cats = new ArrayList<Cat>();
cats.add(new Cat("Behemoth"));
}
Ang mga bagong item ay idinagdag sa dulo ng listahan. Ngayon ay walang panganib na umapaw sa array, kaya ang paraang ito ay ganap na ligtas. Sa pamamagitan ng paraan, ang ArrayList ay hindi lamang makakahanap ng isang bagay sa pamamagitan ng index nito, kundi pati na rin sa kabaligtaran: maaari itong gumamit ng isang sanggunian upang mahanap ang index ng isang bagay sa ArrayList ! Ito ay para sa paraan ng indexOf() : Nagpapasa kami ng reference sa bagay na gusto namin, at ibinabalik ng indexOf() ang index nito:
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);
}
Output: 0 Tama iyan. Ang aming thomas object ay talagang naka-imbak sa elemento 0. Ang mga array ay hindi lamang may mga kakulangan. Mayroon din silang hindi mapag-aalinlanganang mga pakinabang. Isa sa mga ito ay ang kakayahang maghanap ng mga elemento sa pamamagitan ng index. Dahil itinuturo namin ang isang index, ibig sabihin, sa isang tiyak na memory address, ang paghahanap ng array sa ganitong paraan ay napakabilis. ArrayListalam din kung paano gawin ito! Ang get() method ay nagpapatupad nito:
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'} Bilang karagdagan, madali mong malalaman kung ang ArrayList ay naglalaman ng isang partikular na bagay. Ginagawa ito gamit ang ArrayList contains() method:
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));
}
Sinusuri ng pamamaraan kung ang panloob na array ng ArrayList ay naglalaman ng elemento, at nagbabalik ng boolean (true o false). Output: false At isa pang mahalagang bagay tungkol sa pagpasok. Hinahayaan ka ng ArrayList na gumamit ng index upang magpasok ng mga elemento hindi lamang sa dulo ng array, ngunit kahit saan. Mayroon itong dalawang pamamaraan para dito:
ArrayList add(int index, Cat element)
ArrayList set(int index, Cat element)
Bilang mga argumento, ang parehong mga pamamaraan ay kumukuha ng index ng posisyon kung saan mo gustong ipasok, at isang sanggunian sa mismong bagay. Ang pagkakaiba ay ang pagpasok gamit ang set() ay nag-o-overwrite sa lumang halaga. Ang pagpasok gamit ang add() ay unang nagbabago ng isa sa lahat ng elemento mula sa [index] hanggang sa dulo ng array, at pagkatapos ay idinaragdag ang tinukoy na bagay sa nagresultang walang laman na posisyon.
Narito ang isang halimbawa:
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());
}
Output: [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] Mayroon kaming listahan ng 2 pusa . Pagkatapos ay nagpasok kami ng isa pa bilang elemento 0 gamit ang set() na pamamaraan. Bilang resulta, ang lumang elemento ay napalitan ng bago.
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());
}
At dito nakikita natin na ang add() ay gumagana nang iba. Inilipat nito ang lahat ng elemento sa kanan at pagkatapos ay isusulat ang bagong halaga bilang elemento 0. Output: [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] Upang ganap na i-clear ang listahan, ginagamit namin ang clear() na paraan:
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());
}
Output: [] Inalis ang lahat sa listahan. Siyanga pala, pakitandaan: hindi tulad ng mga array, in-override ng ArrayList ang toString() na paraan at ipinapakita na ang listahan nang naaangkop bilang mga string. Sa mga ordinaryong array, kinailangan naming gamitin ang Arrays class para dito. At dahil nabanggit ko ang Arrays : Hinahayaan ka ng Java na madaling "lumipat" sa pagitan ng isang array at isang ArrayList , ibig sabihin, i-convert ang isa't isa. Ang klase ng Arrays ay mayroong Arrays.asList() na pamamaraan para dito. Ginagamit namin ito upang makuha ang mga nilalaman bilang isang array at ipasa ang mga ito sa aming ArrayList constructor:
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'}] Maaari ka ring pumunta sa kabilang direksyon: get isang array mula sa isang ArrayList object. Ginagawa namin ito gamit ang toArray() na pamamaraan:
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));
}
Tandaan: nagpasa kami ng isang walang laman na array sa toArray() method. Ito ay hindi isang error. Sa loob ng klase ng ArrayList , ang pamamaraang ito ay ipinatupad sa paraang ang pagpasa sa isang walang laman na hanay ay nagpapataas ng pagganap nito. Isaisip lamang ito para sa hinaharap (siyempre, maaari mong ipasa ang isang hanay ng ilang partikular na laki; gagana rin iyon). Oh, tungkol sa laki. Ang kasalukuyang laki ng listahan ay matatagpuan gamit ang size() na paraan:
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());
}
Mahalagang maunawaan na hindi tulad ng pag-aari ng haba ng array , ibinabalik ng ArrayList.size() na paraan ang aktwal na bilang ng mga elemento, hindi ang orihinal na kapasidad. Pagkatapos ng lahat, hindi kami tumukoy ng laki sa paggawa ng ArrayList . Gayunpaman, maaari mong tukuyin ito - ang ArrayList ay may angkop na tagabuo. Ngunit sa mga tuntunin ng pagdaragdag ng mga bagong elemento, hindi nito binabago ang pag-uugali nito:
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());
}
Output ng console: 4 Gumawa kami ng listahan ng 2 elemento, ngunit tahimik itong lumawak kapag kailangan namin ito. Ang isa pang pagsasaalang-alang ay kung gagawa tayo ng napakaliit na listahan sa simula, kakailanganin itong palawakin nang mas madalas, na gagamit ng ilang mapagkukunan. Halos hindi namin nahawakan ang proseso ng pag-alis ng mga elemento mula sa isang ArrayList sa araling ito Siyempre, hindi ito dahil nawala ito sa aming isipan. Inilagay namin ang paksang ito sa isang hiwalay na aralin na matutugunan mo sa ibang pagkakataon :) Upang mapalakas ang iyong natutunan, iminumungkahi naming manood ka ng isang video na aralin mula sa aming Java Course
GO TO FULL VERSION