Java Collections Framework

Panimula

Halos bawat programa ay kailangang mag-imbak ng ilang hanay ng data. Maaaring ito ay mga string at numero, mga bagay, at iba pa. Ang mga array ay isang napakahusay na solusyon sa imbakan. Ngunit ang mga array ay may ilang mga limitasyon. Halimbawa, ang kanilang laki ay naayos, ang mga elemento ay hindi maaaring alisin, at hindi ka maaaring magpasok ng mga elemento sa gitna. Ginawa ang mga koleksyon upang malampasan ang mga ito at ang iba pang mga limitasyon. Ang lahat ng uri ng mga koleksyon (at marami sa kanila, gaya ng makikita natin sa susunod na araling ito) ay may kakayahang baguhin ang kanilang mga sarili nang pabago-bago. Ang ilang mga uri ng koleksyon ay maaaring mag-imbak ng mga nakaayos na elemento at awtomatikong ayusin ang mga bagong elemento habang idinaragdag ang mga ito.

Sa araling ito, makikilala natin ang hierarchy ng klase ng mga batayang koleksyon sa Java Collections Framework . Mayroon ding iba't ibang mga alternatibong aklatan na nagpapalawak ng mga kakayahan ng karaniwang Java Collections Framework . Ang pinakasikat sa mga ito ay Guava (Google Collections Library).

Mga pangunahing interface

Ang diagram ay nagpapakita na mayroong dalawang pangunahing mga interface na ipinatupad upang mabuo ang natitirang mga klase at mga interface.

Tingnan natin ang mga interface na ito:

1. Koleksyon — Isang ordinaryong koleksyon na naglalaman ng isang hanay ng mga elemento (mga bagay). Ang koleksyon na ito ay may mga pangunahing pamamaraan para sa pagtatrabaho sa mga elemento: insert ( add , addAll ), alisin ( remove , removeAll , clear ), paghahanap ( contains , containsAll ), tingnan kung walang laman ang koleksyon ( isEmpty ) at makakuha ng laki ( size ).

2. Mapa — Isang koleksyong nakabalangkas bilang key-value pairs. Bukod dito, ang bawat key sa isang Map ay natatangi: walang dalawang key ang may magkaparehong halaga. Ang koleksyong ito ay kung minsan ay tinatawag na diksyunaryo . Ang mapa ay isang hiwalay na interface. Hindi nito ipinapatupad ang interface ng Collection , ngunit bahagi ito ng Java Collections Framework .

Mga kapaki-pakinabang na pamamaraan para sa pagtatrabaho sa mga elemento sa isang Mapa :

• ipasok ( ilagay , ilagayAll )

• get ( get , keySet , values ​​, entrySet )

• alisin ( tanggalin , alisin )

• paghahanap ( containsKey , containsValue )

• tingnan kung walang laman ang koleksyon ( isEmpty )

• kumuha ng laki ( laki )

Ngayon ay pag-usapan natin ang bawat isa sa kanila.

Interface ng koleksyon

Pinapalawak ng interface ng Collection ang Iterable na interface , na may isang paraan: iterator() . Para sa amin, nangangahulugan ito na ang anumang koleksyon na magmamana ng Iterable ay makakapagbalik ng isang iterator.

Ang iterator ay isang espesyal na bagay na magagamit mo upang ma-access ang mga elemento ng anumang koleksyon, anuman ang partikular na pagpapatupad nito.

Ipinapakita ng figure na 3 interface ang nagmamana ng interface ng Collection : List , Queue at Set . Ngayon ay titingnan natin ang bawat isa sa kanila nang maikli.

Ang listahan ay isang nakaayos na koleksyon na nagbibigay-daan sa mga duplicate na halaga. Ang isang partikular na tampok ng isang Listahan ay ang mga elemento nito ay binibilang at maaaring ma-access sa pamamagitan ng numero (index).

Ang isang Queue ay nag-iimbak ng mga elemento sa pagkakasunud-sunod na idinagdag sa mga ito sa pila.

Hindi tulad ng isang listahan, ang isang Set ay kumakatawan sa isang hindi nakaayos na koleksyon na hindi pinapayagan ang mga paulit-ulit na elemento. Ang Set interface ay tumutugma sa konsepto ng isang mathematical set .

Mga pagpapatupad ng interface ng Mapa

Makikita natin na ang interface ng Map ay kumakatawan sa isang pagmamapa sa pagitan ng mga natatanging key at value.

interface Map<K, V>

kung saan ang K ay ang uri ng mga susi at ang V ay ang uri ng mga nakaimbak na halaga.

Gamit ang isang key, maaari kaming kumuha ng data mula sa isang Map . Upang magdagdag ng elemento sa isang Map , dapat tayong tumukoy ng key at value.

Tingnan natin ang ilang pagpapatupad ng Map :

1. Ang HashMap ay isang pagpapatupad ng Map na nakabatay sa mga hash table. Maaari itong mag-imbak ng mga susi at halaga ng anumang uri, kabilang ang null . Ang pagkakasunud-sunod ng mga elemento ay hindi ginagarantiyahan.

2. Ang LinkedHashMap ay isang istraktura ng data na nag-iimbak ng data bilang isang naka-link na listahan ng mga elemento. Ang mga elemento ay lilitaw sa listahan sa pagkakasunud-sunod kung saan sila idinagdag.

3. Ipinapatupad ng TreeMap ang interface ng SortedMap (sa pamamagitan ng interface ng NavigableMap ). Ang mga elemento sa istrukturang ito ay iniimbak sa pinagsunod-sunod na pagkakasunud-sunod (kapag may idinagdag na bagong elemento, ang koleksyon ay awtomatikong inaayos). Mahusay ang TreeMap para sa pag-iimbak ng malalaking halaga ng pinagsunod-sunod na data na may mabilis na pagkuha.

Mga lumang koleksyon:

Ang Java ay may mga hindi na ginagamit na koleksyon mula sa mga nakaraang bersyon (upang mapanatili ang pabalik na pagkakatugma). Ang mga lumang koleksyon na ito ay hindi dapat gamitin sa bagong code:

• Enumeration — kahalintulad sa Interface ng Iterator ;

• Vector — isang nakaayos na listahan ng mga elemento at kahalintulad sa klase ng ArrayList ;

• Stack — isang pagpapatupad ng istraktura ng data ng stack, na nag-iimbak at nagmamanipula ng mga elemento tulad ng kung paano ka makikipag-ugnayan sa isang stack ng mga aklat. May mga pamamaraan para sa pagdaragdag ng mga elemento sa stack ( push ) at pagtanggal ng mga ito ( pop );

• Diksyunaryo — kahalintulad sa interface ng Map , ngunit ito ay isang abstract na klase;

• Hashtable — kahalintulad sa HashMap .

Maaari kang magbasa nang higit pa tungkol sa Framework ng Mga Koleksyon sa artikulong ito .