Java Vector

Marahil ay nakatagpo ka na ng mga arrays sa Java, at alam mo na ang isa sa kanilang mga pangunahing disbentaha ay ang laki ng katatagan. Kapag nakagawa ka na ng array ng isang partikular na laki, hindi mo na iyon mababago sa ibang pagkakataon. Mayroong ilang mga klase ng framework ng Java Collection sa wikang Java na lumulutas sa problemang ito. Isa sa mga ito ay ang Java Vector Class. Tatalakayin ito sa artikulong ito.

Ano ang Vector Class

Tulad ng isinulat namin sa paunang salita, ang Vector class mula sa Java Collection Framework ay nag-aalis ng problema sa static na laki ng mga array. Ang Java Vector ay isang uri ng isang dynamic na array at maaaring lumaki o lumiit sa laki. Gamit ang Vector collection class, maaari tayong mag-imbak ng isang pangkat ng mga elemento bilang mga simpleng bagay at manipulahin ang mga ito sa pamamagitan ng iba't ibang pamamaraan. Ang Vector class ay makukuha mula sa java.util package. Kaya, ang Vector sa Java ay maaaring gamitin kung hindi mo pa alam ang laki ng array, o kung kailangan mo ng "array" na maaaring magbago ng mga sukat sa buong buhay ng programa. Dapat sabihin kaagad na ang Vectormedyo luma na ang klase, at may lumabas na mga koleksyon sa ibang pagkakataon na maaaring palitan ito sa karamihan ng mga kaso. Ang sikat na "analogue" ng Java Vector ay ang klase ng ArrayList . Ang pinakamahalagang pagkakaiba sa pagitan ng mga klase sa isa't isa ay ang Vector ay naka-synchronize, habang ang ArrayList ay hindi. Pag-uusapan natin ang iba pang mga pagkakaiba sa pagitan ng dalawang klase na ito at mas modernong mga analogue ng Vector class sa ibang pagkakataon sa seksyong "Ano ang mali sa Vector class".

Mga Paraan ng Java Vector

Narito ang Java Vector Methods:

• Ang void add(int index, Object element) ay naglalagay ng tinukoy na elemento sa tinukoy na posisyon ng vector.

• Ang boolean add(Object o) ay nagdaragdag ng tinukoy na elemento sa dulo ng vector.

• Ang boolean addAll(Collection c) ay nagdaragdag ng lahat ng mga elemento sa tinukoy na koleksyon sa dulo ng vector, sa pagkakasunud-sunod na ibabalik sila ng tinukoy na iterator ng koleksyon.

• Ang boolean addAll(int index, Collection c) ay naglalagay ng lahat ng elemento sa loob ng tinukoy na Collection sa vector sa tinukoy na posisyon.

• Ang void addElement(Object obj) ay nagdaragdag ng tinukoy na bahagi sa dulo ng vector na ito, na pinapataas ng isa ang laki nito.

• int capacity() ay nagbabalik ng kasalukuyang kapasidad ng vector na ito.

• inaalis ng void clear() ang lahat ng elemento mula sa vector na ito.

• Ang Object clone() ay nagbabalik ng clone ng vector na ito.

• Ang boolean ay naglalaman ng(Object elem) ay sumusubok kung ang tinukoy na bagay ay isang bahagi sa vector na ito.

• Ang boolean containsAll(Collection c) ay nagbabalik ng true kung ang vector ay naglalaman ng lahat ng elemento ng tinukoy na Collection.

• kinokopya ng void copyInto(Object[] anArray) ang mga bahagi ng vector na ito sa tinukoy na array.

• Ang Object elementAt(int index) ay nagbabalik ng bahagi sa tinukoy na index.

• Ang enumeration elements() ay nagbabalik ng enumeration ng mga bahagi ng vector na ito.

• pinapataas ng void ensureCapacity(int minCapacity) ang kapasidad ng vector na ito, kung kinakailangan, upang matiyak na maaari nitong hawakan ang kahit man lang bilang ng mga bahagi na ibinigay ng argumento ng pinakamababang kapasidad.

• Ang boolean equals(Object o) ay inihahambing ang tinukoy na object sa vector na ito.

• Ibinabalik ng Object firstElement() ang unang bahagi (elemento sa index 0) ng vector na ito.

• Ibinabalik ng object get(int index) ang elemento sa tinukoy na posisyon sa vector na ito.

• int hashCode() ay nagbabalik ng hash code value para sa vector na ito.

• Ang int indexOf(Object elem) ay naghahanap para sa unang paglitaw ng ibinigay na argumento, pagsubok para sa pagkakapantay-pantay gamit ang equals method.

• Ang int indexOf(Object elem, int index) ay naghahanap para sa unang paglitaw ng ibinigay na argumento, simula sa index, at pagsubok para sa pagkakapantay-pantay gamit ang equals method.

• inilalagay ng void insertElementAt(Object obj, int index) ang tinukoy na object bilang bahagi sa vector na ito sa tinukoy na index.

• Sinusubukan ng boolean isEmpty() ang vector na ito para sa mga nawawalang bahagi.

• Ibinabalik ng Object lastElement() ang huling bahagi ng vector.

• int lastIndexOf(Object elem) ay nagbabalik ng index ng huling paglitaw ng tinukoy na object sa vector na ito.

• int lastIndexOf(Object elem, int index) ay naghahanap pabalik para sa tinukoy na object, simula sa tinukoy na index, at ibinabalik ang index dito.

• Ang Object remove(int index) ay nag-aalis ng elemento sa tinukoy na posisyon sa vector na ito.

• Tinatanggal ng boolean remove(Object o) ang unang paglitaw ng tinukoy na elemento sa vector na ito. Kung ang vector ay walang elemento, hindi ito nagbabago.

• Tinatanggal ng boolean removeAll(Collection c) ang lahat ng elemento mula sa vector na nakapaloob sa tinukoy na Collection.

• ang void removeAllElements() ay nag-aalis ng lahat ng bahagi mula sa vector at itinatakda ang laki nito sa zero.

• Tinatanggal ng boolean removeElement(Object obj) ang unang (pinakamababang index) na paglitaw ng argument mula sa vector na ito.

• ang void removeElementAt(int index) ay nag-aalis ng isang elemento sa index.

• ang protected void removeRange(int fromIndex, int toIndex) ay nag-aalis mula sa Listahan na ito ng lahat ng elemento na ang index ay nasa pagitan ng fromIndex, inclusive, at toIndex, eksklusibo.

• Ang boolean retainAll(Collection c) ay nagpapanatili lamang ng mga elemento sa vector na nakapaloob sa tinukoy na Collection.

• Ang Object set(int index, Object element) ay pinapalitan ang elemento sa tinukoy na posisyon sa vector na ito ng tinukoy na elemento.

• void setElementAt(Object obj, int index) ay nagtatakda ng component sa tinukoy na index ng vector na ito bilang ibinigay na object.

• void setSize(int newSize) nagtatakda ng laki ng vector na ito.

• int size() ay nagbabalik ng bilang ng mga bahagi sa vector na ito.

• Ang listahan ng subList(int fromIndex, int toIndex) ay nagbabalik ng representasyon (view) ng bahagi ng Listahan na ito sa pagitan ng fromIndex, inclusive, at toIndex, eksklusibo.

• Ang Object[] toArray() ay nagbabalik ng array na naglalaman ng lahat ng elemento ng vector na ito sa tamang pagkakasunod-sunod.

• Ang Object[] toArray(Object[] a) ay nagbabalik ng array na naglalaman ng lahat ng elemento ng vector na ito sa tamang pagkakasunod-sunod; ang uri ng pagpapatupad ng ibinalik na array ay ang uri ng tinukoy na array.

• Ang String toString() ay nagbabalik ng string na representasyon ng vector na ito na naglalaman ng string na representasyon ng bawat elemento.

• void trimToSize() trims ang kapasidad ng vector na ito sa kasalukuyang laki ng vector.

Halimbawa ng Java Vector

import java.util.Vector;

public class VectorExample {

   public static void main(String[] args) {
       Vector vector = new Vector();
       System.out.println("the size of the empty vector = " +  vector.size());
       //adding some vector elements
       vector.add("Johnny");
       vector.add("Ivy");
       vector.add("Ricky");
       System.out.println(vector); 
       
       //adding more vector elements       
       vector.add("Johnny");
       vector.add("Paul");
       System.out.println(vector);
       System.out.println("the size of the vector = " +  vector.size());
       System.out.println("the first element of the vector = " + vector.firstElement());

       //here the program will print out the first appearance of "Johnny" element
       System.out.println(vector.indexOf("Johnny"));
       //program will print out the first appearance of "Johnny" element starting from the element 1
       System.out.println(vector.indexOf("Johnny", 1));
       vector.clear(); //deleting all vector elements
       System.out.println("the size of the vector after clear method = " +  vector.size());

   }
}

Ang output ng program na ito ay narito sa ibaba:

Ano ang mali sa Vector Class?

Ayon sa dokumentasyon ng Java Vector class, kung hindi mo kailangan ng thread-safe na pagpapatupad sa iyong program, inirerekomendang gamitin ang ArrayList sa halip na Vector (Collection Framework na mas epektibong kalahok). Baguhin natin nang kaunti ang halimbawa sa itaas, gamit ang klase ng ArrayList sa halip na Vector .

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {

       public static void main(String[] args) {
           List vector = new ArrayList();
           //Vector vector = new Vector();
           System.out.println("the size of the empty vector = " +  vector.size());
           vector.add("Johnny");
           vector.add("Ivy");
           vector.add("Ricky");
           System.out.println(vector);
           vector.add("Johnny");
           vector.add("Paul");
           System.out.println(vector);
           System.out.println("the size of the vector = " +  vector.size());
           //System.out.println("the first element of the vector = " + vector.firstElement());

           //here the program will print out the first appearance of "Johnny" element
           System.out.println(vector.indexOf("Johnny"));
           //program will print out the first appearance of "Johnny" element starting from the element 1
           //System.out.println(vector.indexOf("Johnny", 1));
           vector.clear();
           System.out.println("the size of the vector after clear method = " +  vector.size());

       }
   }

Nagkomento kami sa linya gamit ang vector.indexOf("Johnny", 1) , dahil walang ganoong paraan sa variation na ito sa klase ng ArrayList . Para sa parehong dahilan, ang vector.firstElement() line ay nagkomento. Sa lahat ng iba pang aspeto, ang programa ay gumagawa ng parehong resulta gaya ng una. Siyempre, sa gayong halimbawa, hindi malinaw kung bakit mas mahusay ang ArrayList kaysa Vector . Nangangailangan ito ng higit pang kaalaman tungkol sa, halimbawa, mga thread. Inilista namin ang mga dahilan dito. Una, kahit na ang Vector class ay naka-synchronize, hindi ito matatawag na ganap na thread-safe, bagama't ito ay tila kakaiba. Ang katotohanan ay na-synchronize ng Vector ang bawat operasyon, hindi ang buong Vectorhalimbawa mismo. Maaari itong maging problema sa mga program kung saan kailangan mong i-synchronize ang buong hanay ng mga operasyon sa halip na mga indibidwal na operasyon. Sabihin, kung ang isang thread ay umuulit sa isang vector at isa pang thread ay structurally modifying ng isang instance ng vector, ang iterator ay magtapon ng isang ConcurrentModificationException . Lumalabas na ang dalawang thread ay maaaring gumana sa isang Vector instance sa parehong oras kung magsagawa sila ng magkaibang mga operasyon. Pangalawa, ang Vectorclass ay walang pinakamahusay na pagganap dahil ang mga bagay nito ay may resizable array at synchronization. Nangangahulugan ang kumbinasyong ito ng karagdagang overhead para sa mga pagpapatakbo ng pagharang, kailangan man ng pag-synchronize o hindi. Oo naman, ito ay nakakaapekto sa pagganap. Bilang karagdagan, ang pag-synchronize ng vector sa bawat operasyon ay mayroon ding negatibong epekto sa pagganap, dahil muli at muli tayong kukuha ng lock para sa bawat operasyon. Kung ang buong instance ng klase ay naka-synchronize, ang lock ay makukuha din ng isang beses, na mas mahusay. Pangatlo, sinusuportahan ng Vector ang ilang legacy na pamamaraan. Halimbawa mga elemento(). Ang pamamaraang ito ay nagbabalik ng isang enumeration ng mga bahagi ng vector. Ang mga programmer ay kadalasang gumagamit ng Iterator o ListIterator sa Enumeration, at para sa ilang kadahilanan. Sa partikular, ang Enumeration ay walang tinukoy na paraan ng pag-alis () , na nangangahulugan na ang listahan ay hindi maaaring baguhin sa istruktura sa panahon ng pag-ulit. Gayundin, hindi tulad ng ListIterator, ang Enumeration ay hindi nag-aalok ng bidirectional na pag-access. Tulad ng nakikita mo, ang Vector ay may kaunting mga problema. Paano kung kailangan mo pa rin ng isang thread-safe na pagpapatupad ng List interface? Sa kasong ito, hindi makakatulong ang ArrayList , ngunit maaari mong gamitin, halimbawa, ang klase ng CopyOnWriteArrayList sa halip na Vector ; ito ay nakaposisyon bilang isang thread-safe na variant ng ArrayList. Maaari mo ring i-synchronize ang ArrayList gamit ang Collections synchronizedList() na pamamaraan.

May mga problema talaga si Vector... bakit nasa Java pa rin at bakit dapat ituro?

Ang tanong ay lumitaw: bakit tayo nag-aaral ng klase ng Vector ? At bakit hindi pa ito naalis sa Java? Ang katotohanan ay ang Java ay nagpapahayag ng prinsipyo ng pabalik na pagkakatugma. Nangangahulugan ito na ang lahat ng lumang code na isinulat maraming taon na ang nakalipas ay mauunawaan ng mga modernong bersyon ng Java. Bilang karagdagan, mayroong kaunting mga aplikasyon sa antas ng enterprise sa kapaligiran ng Java na suportado ng mga dekada. Posible na kailangan mong harapin ang gayong "dinosaur" sa iyong trabaho, kaya kailangan mong maging handa para sa mga sorpresa, tulad ng code na may hindi epektibong mga legacy na klase.