Nilalaman

• Tsart ng paghahambing
• Kahulugan ng ArrayList
• Kahulugan ng Vector
• Pagkakatulad:
• Konklusyon:

Parehong ArrayList at Vector pareho ang mga klase sa ilalim ng hierarchy ng Collection Framework. Ang ArrayList at Vector, pareho ay ginagamit upang lumikha ng isang pabago-bagong hanay ng mga bagay kung saan maaaring lumaki ang array sa laki at kung kinakailangan. Mayroong dalawang pangunahing pagkakaiba-iba na makilala ang ArrayList at Vector ay ang Vector ay kabilang sa mga klase ng Legacy na kalaunan ay muling nag-reaksyon upang suportahan ang mga klase ng koleksyon samantalang, ang isang ArrayList ay isang pamantayang klase ng koleksyon. Ang isa pang mahalagang pagkakaiba ay ang ArrayList ay hindi naka-synchronize sa kabilang banda; Ang Vector ay naka-synchronize.

Pag-aralan natin ang ilang iba pang pagkakaiba sa tulong ng Comparison Chart na ipinakita sa ibaba.

1. Tsart ng paghahambing
2. Kahulugan
3. Pangunahing Pagkakaiba
4. Pagkakatulad
5. Konklusyon

Tsart ng paghahambing

Batayan para sa Paghahambing	ArrayList	Vector
Pangunahing	Ang klase ng ArrayList ay hindi naka-synchronize.	Ang klase ng Vector ay naka-synchronize.
Klase ng pamana	Ang ArrayList ay isang karaniwang klase ng Koleksyon.	Ang Vector ay isang legacy class, muling inhinyero upang suportahan ang klase ng koleksyon.
Pahayag ng Klase	klase ArrayList	klase ng Vector
Pagpapansin	Kapag hindi tinukoy ang isang ArrayList ay nadagdagan ng kalahati ng laki nito.	Kapag hindi tinukoy, ang isang vector ay nadagdagan upang doble ang laki nito.
Pagganap	Tulad ng ArrayList ay hindi nai-synchronise, mas mabilis itong nagpapatakbo kaysa Vector.	Tulad ng pag-synchronize ng Vector, nagpapatakbo ito ng mas mabagal kaysa sa ArrayList.
Enumeration / Iterator	Gumagamit ang ArrayList ng interface ng Iterator upang maglakbay sa mga bagay na nakaimbak sa ArrayList.	Gumagamit ang Vector ng Enumeration pati na rin ang interface ng Iterator upang maipasa ang mga bagay na nakaimbak sa Vectors.

Kahulugan ng ArrayList

Ang ArrayList ay kabilang sa listahan ng mga karaniwang klase ng koleksyon. Ang klase ng ArrayList ay tinukoy sa loob ng java.util package, pinalawak nito ang AbstractList klase na isa ring pamantayang klase ng koleksyon, at ipinatutupad din nito Listahan, isang interface na tinukoy sa Mga Koleksyon ng Koleksyon. Sa Java, ang isang karaniwang hanay ay palaging may nakapirming haba. Nangangahulugan ito kapag nilikha; hindi ito pabagu-bago ng lumaki o pag-urong sa laki. Kaya, dapat mong magkaroon ng naunang kaalaman sa haba ng array na ginagamit mo. Ngunit, kung minsan maaaring mangyari na ang kinakailangang haba ay ipinahayag sa runtime kaya, upang mahawakan ang ganitong uri ng sitwasyon na ipinakilala ng java sa ArrayList.

Ang ArrayList ay klase na ginagamit para sa pabago-bagong paglikha ng isang laruang nagtataglay ng mga sanggunian sa mga bagay. Ang laruang ito ay maaaring lumago sa laki at kung kinakailangan. Ang pahayag ng klase ay bilang sumusunod:

klase ArrayList

Dito, tinutukoy ng E ang uri ng mga bagay na hahawakan ng isang array. Ang array na nilikha ay may variable na haba, at nagdaragdag at bumababa sa laki kapag ang mga bagay ay idinagdag o tinanggal mula sa listahan.

Ang ArrayList ay hindi naka-synchronize na nangangahulugang, higit sa isang thread ay maaaring gumana sa array nang sabay. Halimbawa, kung ang isang thread ay nagdaragdag ng isang sangguniang object sa array at ang isa pang thread ay nag-aalis ng isang sangguniang object mula sa parehong hanay nang sabay. Ang paglikha ng isang dynamic na hanay gamit ang klase ng ArrayList:

ArrayList S1 = bagong ArrayList(); System.out.ln ("Paunang laki ng S1:" + S1.size ()); S1.add ("T"); S1.add ("C"); S1.add ("H"); S1.add (1, "E"); System.out.ln ("Matapos ang karagdagan S1 ay naglalaman ng:" + S1); System.out.ln ("Sukat ng S1 pagkatapos ng karagdagan:" + S1.size ()); S1.remove ("T"); S1.remove (2); System.out.ln ("Matapos ang pagtanggal ng S1 ay naglalaman ng:" + S1); System.out.ln ("Sukat ng S1 pagkatapos ng pagtanggal:" + S1.size ()); // OutputInisyal na laki ng S1: 0 Pagkatapos ng karagdagan S1 ay naglalaman ng:; Sukat ng S1 pagkatapos ng karagdagan: 4 Pagkatapos ng pagtanggal S1 ay naglalaman ng: Sukat ng S1 pagkatapos ng pagtanggal: 2

Sa code sa itaas, makikita mo iyon; Gumawa ako ng isang hanay ng mga bagay ng uri ng string. Nagdagdag ako ng ilang mga bagay sa array S1 gamit ang add () na pamamaraan, at kalaunan tinanggal ang ilang mga bagay gamit ang alisin () na pamamaraan. Maaari mong obserbahan kung hindi mo tinukoy ang paunang sukat ng array na ito ay haba ng '0'. Tulad ng nakikita mo na lumalaki ang array at pag-urong sa laki habang idinagdag mo at tinanggal ang mga elemento.

Kahulugan ng Vector

Ang Vector ay isang klase ng Legacy na muling nakikilala upang suportahan ang klase ng koleksyon sa hierarchy ng Collection Framework. Ang klase ng vector ay tinukoy din sa java.util package, pinalawak ng AbstractList klase at ipinatupad ng Listahan interface. Ang klase ng Vector ay idineklarang sumusunod:

klase ng Vector

Dito, tinukoy ng E ang uri ng bagay na maiimbak sa isang hanay. Ang isang array na nilikha gamit ang klase ng Vector ay may variable na haba. Ito ay nagdaragdag ng doble ang laki nito kung hindi tinukoy ang pagdaragdag. Unawain natin ang paglikha ng array gamit ang Vector.

Vector V = bagong Vector(1,1); V.addElement ("Tech"); V.addElement ("Mga Pagkakaiba-iba"); System.out.ln ("Kapasidad pagkatapos ng 2 karagdagan:" + V.capacity ()); V.addElement ("Sa pagitan ng"); V.addElement ("Vectors"); System.out.ln ("Kasalukuyang kapasidad:" + V.capacity ()); // Kakayahang Output pagkatapos ng 2 karagdagan: 2 Kasalukuyang kapasidad: 4

Sa itaas na code maaari mong makita iyon, partikular na nabanggit ko ang laki at pagtaas ng halaga sa tagabuo ng Vector ayon sa pagkakabanggit, habang idineklara ang hanay ng mga bagay na string. Samakatuwid, maaari mong obserbahan na bilang limitasyon ng pagtatapos ng array, nadaragdagan ito ng halaga na ibinigay sa tagabuo habang idineklara.

1. Maramihang mga thread ay maaaring gumana sa ArrayList nang sabay-sabay samakatuwid ito ay isinasaalang-alang hindi naka-synchronise. Hindi tulad ng ArrayList, isang solong thread lamang ang maaaring gumana sa isang vector nang sabay-sabay; samakatuwid ito ay tinawag Naka-synchronize.
2. Sa isang maagang bersyon ng Java, ang ilang mga klase at mga interface ay magbibigay ng mga pamamaraan upang mag-imbak ng mga bagay na tinawag nilang mga klase ng Legacy Vector ay isa sa klase ng Legacy ng Java. Nang maglaon, ang mga uring pamana na ito ay muling nabigyan ng reaksyon upang suportahan ang klase ng Koleksyon samantalang, ang klase ng ArrayList ay isang karaniwang Class Class.
3. Kapag ang limitasyon ng isang array ay ganap na magamit at isang bagong bagay ay idinagdag sa tabi ng naubos na array, ang laki nito ay lumalaki sa parehong mga kaso ie sa ArrayList pati na rin sa Vector ngunit, ang pagkakaiba ay sa ArrayList, kung hindi tinukoy ang laki ay nadagdagan ng 50% ng kasalukuyang hanay samantalang, sa hanay ng Vector ay doble ang laki kung ang tinukoy na halaga ay hindi tinukoy.
4. Gumagamit ang Vector ng Enumeration pati na rin si Iterator upang maglakbay sa isang hanay samantalang, ang isang ArrayList ay gumagamit lamang ng tagasunod para sa paglalakad ng isang hanay.
5. Dahil ang ArrayList ay Hindi Nai-synchronise at maraming mga thread ang maaaring gumana dito sa parehong oras ang pagganap nito ay mas mahusay kaysa sa Vector kung saan ang isang thread lamang ang maaaring gumana nang sabay-sabay.

Pagkakatulad:

1. Parehong tinukoy ang ArrayList at Vector sa java.util package.
2. Parehong pinalawak ng ArrayList at Vector ang klase ng AbsractList.
3. Parehong ipinatupad ng ArrayList at Vector ang interface ng Listahan.
4. Parehong ginagamit ang ArrayList at Vector upang lumikha ng isang dynamic na hanay na lumalaki kung kinakailangan.
5. Parehong may hawak na sanggunian ang ArrayList at Vector.

Konklusyon:

Nagtapos ako sa pamamagitan ng pagsasabi na ang paggamit ng ArrayList ay mas mahusay kaysa sa paggamit ng Vector dahil ito ay gumaganap nang mas mabilis at mas mahusay.