Ano ang Vector sa Java at paano natin ito magagamit?

Ang blog na ito sa 'Mga Vector sa Java' ay makakatulong sa iyo na maunawaan kung paano ang klase ng vector ay naiiba mula sa ArrayList at tutulong sa iyo na malaman ang tungkol sa iba't ibang mga pamamaraan na kasangkot.

Mga Vector sa ay isa sa mga pinaka-karaniwang ginagamit na istraktura ng data sa mundo ng programa.Alam nating lahat iyon Mga array ay mga istruktura ng data na humahawak ng data sa isang linear mode. Ang mga Vector ay nag-iimbak din ng data sa isang linear na paraan, ngunit hindi tulad ng mga Array, wala silang isang nakapirming laki. Sa halip, ang kanilang laki ay maaaring madagdagan ayon sa demand.

Ang klase ng Vector ay isang klase ng bata ng Listahan ng Abstract klase at nagpapatupad sa Listahan .Upang magamit ang mga Vector, kailangan muna naming mag-import ng klase ng Vector mula sa java.util package:



i-import ang java.util.Vector

Sa artikulong ito, tatalakayin namin ang mga sumusunod na konsepto ng mga vector:

Magsimula na tayo!

Kalamangan s ng Vector sa Java

  • Ang pag-aari ng pagkakaroon ng isang pabago-bagong sukat ay lubhang kapaki-pakinabang dahil iniiwasan ang pag-aaksaya ng memorya kung sakaling hindi namin alam ang laki ng istraktura ng data sa oras ng pagdedeklara.
  • Kapag nais naming baguhin ang laki ng aming istraktura ng data sa gitna ng isang programa, maaaring mapatunayan ng mga vector na maging napaka kapaki-pakinabang.

Ang pag-aari ng pagkakaroon ng isang pabago-bagong sukat ay hindi natatangi sa Mga Vector sa Java. Ang isa pang istraktura ng data, na kilala bilang ArrayList ay nagpapakita rin ng pag-aari ng pagkakaroon ng isang pabago-bagong sukat. Gayunpaman, ang mga Vector ay naiiba mula sa ArrayLists dahil sa isang pares ng mga kadahilanan:

  • Una, ang mga Vector ay na-synchronize na nagbibigay dito ng kalamangan kumpara sa mga programa dahil may mga panganib ng katiwalian sa data.
  • Pangalawa, ang mga Vector ay may ilang mga pagpapaandar na legacy na maaaring ipatupad lamang sa mga vector at hindi sa ArrayLists.

Paano Mag-access ng Mga Elemento sa Vector

Maaari naming ma-access ang mga kasapi ng data sa pamamagitan lamang ng paggamit ng index ng elemento, tulad ng pag-access namin sa mga elemento sa Mga Array.

Halimbawa- Kung nais naming i-access ang pangatlong elemento sa isang vector v, simpleng tinukoy namin ito bilang v [3].

malalim na kopya vs mababaw na kopya ng java

Mga Tagabuo ng Vector

Nakalista sa ibaba ang maraming pagkakaiba-iba ng vector tagapagtayo magagamit upang magamit:

  1. Vector (int initialCapacity, int Increment) - Bumubuo ng isang vector na may ibinigay na paunang Kapasidad at ang pagtaas nito sa laki.
  2. Vector (int initialCapacity) - Bumubuo ng isang walang laman na vector na may ibinigay na paunangCapacity. Sa kasong ito, ang pagtaas ay zero.
  3. Vector () - Bumubuo ng isang default na vector ng kapasidad 10.
  4. Vector (Koleksyon c) - Bumubuo ng isang vector na may isang ibinigay na koleksyon, ang pagkakasunud-sunod ng mga elemento ay pareho ng ibinalik ng iterator ng koleksyon.

Mayroon ding tatlong protektadong mga parameter sa mga vector

  1. Int kapasidadIncrement () - Awtomatiko nitong pinapataas ang kapasidad ng vector kapag ang laki ay nagiging mas malaki kaysa sa kapasidad.
  2. Int elementCount () - sabihin ang bilang ng mga elemento sa vector
  3. Bagay [] elementData () - array kung saan nakaimbak ang mga elemento ng vector

Karamihan sa Mga Karaniwang Error sa Pagdeklara ng Mga Vector

  • Itinapon ni Vector ang isang IlegalArgumentException kung ang InitialSize ng vector na tinukoy ay negatibo.
  • Kung ang tinukoy na koleksyon ay null, Itapon NullPointerException

Tandaan:

  1. Kung ang pagtaas ng vector ay hindi tinukoy sa gayon ang kapasidad ay magigingdinoble sa bawat ikot ng pagtaas.
  2. Ang kapasidad ng isang vector ay hindi maaaring mas mababa sa laki, maaari itong katumbas nito.

Isaalang-alang natin ang isang halimbawa ng pagsisimula ng Mga Tagabuo ng Vector.

Halimbawa: Inisyal ang Mga Tagabuo ng Vector

/ Java code na naglalarawan ng mga Vector Consuctor na nag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {// lumikha ng default vector Vector v1 = bagong Vector () // lumikha ng isang vector ng ibinigay na Sukat ng Vector v2 = bagong Vector (20) // lumikha ng isang vector ng ibinigay na Sukat at Pagdagdag ng Vector v3 = bagong Vector (30,10) v2.add (100) v2.add (100) v2.add (100) // lumikha ng isang vector na may ibinigay koleksyon Vector v4 = bagong Vector (v2) System.out.println ('Vector v1 ng kapasidad' + v1.capacity ()) System.out.println ('Vector v2 ng kapasidad' + v2.capacity ()) System.out .println ('Vector v3 ng kapasidad' + v3.capacity ()) System.out.println ('Vector v4 ng kapasidad' + v4.capacity ())}

Paglabas

Mga Bumubuo - Mga Vector sa Java - Edureka

Paglalaan ng memorya ng mga vector

Sa ngayon, dapat mong maunawaan na ang mga Vector ay walang isang nakapirming laki, sa halip, may kakayahan silang baguhin ang kanilang laki nang pabagu-bago. Maaaring isipin ng isa na ang mga vector ay naglalaan ng hindi tiyak na mahabang espasyo upang mag-imbak ng mga bagay. Ngunit hindi ito ang kaso. Maaaring baguhin ng mga vector ang kanilang laki batay sa dalawang larangan na 'kapasidad' at 'kapasidadIncrement'. Sa una, isang sukat na katumbas ng patlang na 'kapasidad' ay inilalaan kapag ang isang vector ay idineklara. Maaari naming ipasok ang mga elemento na katumbas ng kapasidad. Ngunit sa lalong madaling maipasok ang susunod na elemento, pinapataas nito ang laki ng array sa pamamagitan ng laki na 'kapasidadIncrement'. Samakatuwid, nagagawa nitong baguhin ang laki nito nang pabagu-bago.

Para sa default na tagapagbuo , ang kapasidad ay dinoble tuwing ang kapasidad ay puno at isang bagong elemento ay naisingit.

Halimbawa - Ipagpalagay na mayroon kaming isang vector ng InitialCapacity 5 at kapasidadPagdagdag ng 2. Kaya't ang paunang laki ng vector ay 5 mga elemento Isinasama namin ang 5 mga elemento sa vector na ito isa-isa, lalo na 1,2,3,4,5. Kapag sinubukan naming ipasok ang isa pang elemento sa vector na 6, ang laki ng vector ay madaragdagan ng 2. Samakatuwid ang laki ng vector ay ngayon 7. Kaya't madaling iakma ng vector ang laki nito ayon sa no. ng mga elemento.

Ang isa pang kagiliw-giliw na punto ay na hindi katulad ng mga arrays, ang mga vector ay hindi naglalaman ng mga totoong bagay, ngunit mga sanggunian lamang sa mga bagay. Samakatuwid, pinapayagan ang mga bagay ng iba't ibang mga uri ng data na maiimbak sa parehong vector.

Mga Paraan sa Vector

Tingnan natin ang ilang mga madalas na ginagamit na mga pamamaraan ng vector.

  • Boolean add (Bagay o) - Nagdadagdag ito ng isang elemento sa dulo ng vector.
// Java code na nagpapakita ng boolean add () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1 ) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng listahan v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Ang vector ay' + v)}}

Paglabas

  • Walang bisa na idagdag (int Index, E elemento) - Dinadagdag nito ang ibinigay na elemento sa tinukoy na index sa vector
// Java code showing void add () method import java.util. * Public class Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (0 , 1) // Nagdaragdag ng 1 sa index 0 v.add (1, 'Java') // Nagdaragdag ng 'Java' sa index 1 v.add (2, 'ay') // Adds 'ay' sa index 2 v.add (3, 'Fun') // Nagdaragdag ng 'Kasayahan' sa index 3 v.add (4, '!!!') // Nagdaragdag ng 'Kasayahan' sa index 4 System.out.println (' Ang vector ay '+ v)}}

Paglabas

  • Tanggalin ang Boolean (object o) - Tinatanggal nito ang alisin ang elemento sa ibinigay na index sa vector
// Java code na nagpapakita ng boolean alisin () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1 ) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng ilista ang v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Vector bago alisin' + v) v. alisin (1) System.out.println ('Vector pagkatapos ng pagtanggal '+ v)}}

Paglabas

  • Tanggalin ang BooleanElement ( Object obj) - Tinatanggal nito ang elemento sa pamamagitan ng pangalan nitong obj (hindi ng index number)
// Java code na nagpapakita ng paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng listahan v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Vector bago alisin' + v) v.removeElement ('Java') System.out.println ('Vector pagkatapos alisin '+ v)}}

Paglabas

  • Laki ng int () - Ibinabalik nito ang laki ng vector.
// Java code na nagpapakita ng laki () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (0, 1) // Nagdaragdag ng 1 sa index 0 v.add (1, 'Java') // Nagdaragdag ng 'Java' sa index 1 v.add (2, 'ay') // Adds 'ay' sa index 2 v.add (3, 'Fun') // Nagdaragdag ng 'Kasayahan' sa index 3 System.out.println ('Ang laki ng vector ay' + v.size ())}}

Paglabas

  • Int Capacity () - Ibinabalik nito ang kapasidad ng vector
// Java code na nagpapakita ng kapasidad () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (0, 1) // Nagdaragdag ng 1 sa index 0 v.add (1, 'Java') // Nagdaragdag ng 'Java' sa index 1 v.add (2, 'ay') // Adds 'ay' sa index 2 v.add (3, 'Fun') // Nagdaragdag ng 'Kasayahan' sa index 3 System.out.println ('Ang kapasidad ng vector ay' + v.capacity ())}}

Paglabas

  • Pagkuha ng object (int index) - Ibinabalik nito ang elemento sa ibinigay na posisyon sa vector
// Java code showing get () method import java.util. * Public class Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng listahan v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Ang elemento sa index 1 ay' + v.get (1))}}

Paglabas

  • Object munaElement () - Ibinabalik nito ang unang elemento
// Java code showing firstElement () method import java.util. * Public class Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng listahan v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Ang unang elemento ay' + v.firstElement ())}}

Paglabas

  • Huling objectElement () - Ibinabalik nito ang huling elemento
// Java code na nagpapakita ng hulingElement () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (1) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('is') // Adds 'ay' sa dulo ng listahan v.add ('Kasayahan') // Nagdaragdag ng 'Kasayahan' sa dulo ng listahan ng System.out.println ('Ang huling elemento ay' + v.lastElement ())}}

Paglabas

  • Ang Boolean ay katumbas (Bagay o) - Inihahambing nito ang vector sa tinukoy na bagay para sa pagkakapantay-pantay. Bumabalik ito totoo kung ang lahat ng mga elemento ay totoo sa kanilang kaukulang mga indeks
// Java code na nagpapakita ng boolean ay katumbas ng () paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {pampublikong static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector Vector vcopy = bagong Vector () v.add (1) // Nagdaragdag ng 1 sa dulo ng listahan v.add ('Java') // Nagdaragdag ng 'Java' sa dulo ng listahan v.add ('ay') // Nagdaragdag ' ay 'sa dulo ng listahan v.add (' Kasayahan ') // Nagdaragdag ng' Kasayahan 'sa dulo ng listahan ng vcopy.add (0,1) // Nagdaragdag ng 1 sa index 0 vcopy.add (1, 'Java') // Nagdaragdag ng 'Java' sa index 1 vcopy.add (2, 'ay') // Adds 'ay' sa index 2 vcopy.add (3, 'Fun') // Nagdadagdag ng 'Fun' sa index 3 vcopy.add (4, '!!!') // Nagdaragdag ng 'Kasayahan' sa index 4 kung (v.equals (vcopy)) System.out.println ('Parehong mga vector ay pantay') iba pa System .out.println ('Ang mga vector ay hindi pantay')}}

Paglabas

  • Void trimtosize () - Tinatanggal ng pamamaraang ito ang labis na kapasidad at pinapanatili ang kapasidad upang mahawakan lamang ang mga elemento ibig sabihin katumbas sa laki
// Java code na nagpapakita ng trimToSize () na paraan ng pag-import ng java.util. * Pampublikong klase Pangunahing {public static void main (String [] args) {Vector v = new Vector () // Lumilikha ito ng isang default vector v.add (0, 1) // Nagdaragdag ng 1 sa index 0 v.add (1, 'Java') // Nagdaragdag ng 'Java' sa index 1 v.add (2, 'ay') // Adds 'ay' sa index 2 v.add (3, 'Fun') // Nagdaragdag ng 'Kasayahan' sa index 3 System.out.println ('Ang kapasidad ng vector ay' + v.capacity ()) v.trimToSize () System.out.println ( 'Ang kapasidad ng vector ay' + v.kapasidad ())}}

Paglabas


Ang Iba Mahahalagang Paraan

Sa ngayon dapat ay mayroon kang isang magandang ideya sa kung paano gumana sa mga vector. Kung nais mong tuklasin ang higit pa sa mga pamamaraan ng vector pagkatapos ay tumingin sa ibabang talahanayan na ibinigay.

Pangalan ng Paraan Pag-andar ng Paraan

Ang Boolean ayEmpty ()

sinusuri kung mayroon ang mga elemento o wala

Naglalaman ang Boolean (Bagay o)

ginamit upang suriin ang pagkakaroon ng isang tukoy na elemento, sabihin o

int indexOf (Bagay o)

pagkakaiba sa pagitan ng java at klase

Ibinabalik nito ang index ng elemento o

walang bisa ang pagtanggalRange (int s, int e)

inaalis ang mga elemento mula sa vector simula sa s at nagtatapos sa (e-1)

walang bisa ()

inaalis ang lahat ng mga elemento

walang bisa ang katiyakanCapacity (int c)

Pinapataas nito ang kakayahan sa pamamagitan ng c

walang bisa ang setSize (int s)

Itinatakda nito ang laki sa s. Kung ang laki>, ang labis na kapasidad ay puno ng mga null na halaga. Kung ang s

Elemento ng objectAt (int a)

ibabalik ang elemento na umiiral sa index number a

Itakda ang object (int a, Object o)

pinapalitan ang elemento na naroroon sa index a ng ibinigay na elemento o

Bagay [] saArray ()

nagbabalik ng isang array na naglalaman ng parehong mga elemento tulad ng vector

Pag-clone ng object ()

Ang vector object ay nakopya

Boolean addAll (Koleksyon c)

nagdadagdag ng lahat ng mga elemento ng Koleksyon c sa vector

Boolean addAll (int a, Koleksyon c)

isingit ang lahat ng mga elemento ng Koleksyon c sa vector sa tinukoy na index a

Panatilihin ng BooleanAll (Koleksyon c)

pinapanatili ang lahat ng mga elemento sa vector na mayroon din sa Koleksyon c

Ilista ang subList (int s, int e)

ibabalik ang mga elemento, bilang isang bagay sa Listahan, na nagsisimula sa s at nagtatapos sa (e-1) mula sa vector.

Tulad ng pagtatapos ng bawat mabuting bagay, sa gayon ay ang aming blog sa Vector in . Inaasahan namin na nagawa naming masakop ang lahat ng mga aspeto ng mga java vector sa blog na ito at nakalikom ka ng ilang kaalaman tungkol sa Vector.

Tiyaking nagsasanay ka hangga't maaari at ibalik ang iyong karanasan.

ano ang hashset java

Suriin ang ni Edureka, isang pinagkakatiwalaang kumpanya sa pag-aaral sa online na may isang network na higit sa 250,000 nasiyahan na mga nag-aaral na kumalat sa buong mundo. Narito kami upang matulungan ka sa bawat hakbang sa iyong paglalakbay, para sa pagiging isang bukod sa mga katanungang ito sa panayam sa java, nakakakuha kami ng isang kurikulum na idinisenyo para sa mga mag-aaral at propesyonal na nais na maging isang Java Developer.

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento ng 'Mga Vector sa Java' na ito artikulo at babalikan ka namin sa lalong madaling panahon.