Vector Java

Probabil că ați întâlnit deja matrice în Java și știți că unul dintre principalele lor dezavantaje este constanța dimensiunii. Odată ce ați creat o matrice de o anumită dimensiune, nu o puteți modifica ulterior. Există mai multe clase cadru Java Collection în limbajul Java care rezolvă această problemă. Unul dintre ele este Java Vector Class. Acesta va fi discutat în acest articol.

Ce este Vector Class

După cum am scris în prefață, clasa Vector din Java Collection Framework elimină problema dimensiunii statice a matricelor. Java Vector este un fel de matrice dinamică și poate crește sau micșora în dimensiune. Folosind clasa Vector collection, putem stoca un grup de elemente ca obiecte simple și le putem manipula prin diferite metode. Clasa Vector este disponibilă din pachetul java.util . Astfel, Vector în Java poate fi folosit dacă nu cunoașteți în prealabil dimensiunea matricei, sau dacă aveți nevoie de o „matrice” care poate modifica dimensiunile pe durata de viață a programului. Trebuie spus imediat că Vectorulclasa este deja destul de veche, iar ulterior au apărut colecții care o pot înlocui în marea majoritate a cazurilor. Popularul „analog” al Java Vector este clasa ArrayList . Cea mai importantă diferență dintre aceste clase una față de cealaltă este că Vector este sincronizat, în timp ce ArrayList nu este. Vom vorbi despre alte diferențe dintre aceste două clase și analogii mai moderni ai clasei Vector puțin mai târziu în secțiunea „Ce este în neregulă cu clasa Vector”.

Metode Java Vector

Iată metodele vectoriale Java :

• void add(int index, Object element) inserează elementul specificat în poziția specificată a vectorului.

• boolean add(Object o) adaugă elementul specificat la sfârșitul vectorului.

• boolean addAll(Colecția c) adaugă toate elementele din colecția specificată la sfârșitul vectorului, în ordinea în care sunt returnate de iteratorul de colecție specificat.

• boolean addAll(int index, Collection c) inserează toate elementele din Colecția specificată în vector la poziția specificată.

• void addElement(Object obj) adaugă componenta specificată la sfârșitul acestui vector, mărindu-i dimensiunea cu una.

• int capacitate() returnează capacitatea curentă a acestui vector.

• void clear() elimină toate elementele din acest vector.

• Object clone() returnează o clonă a acestui vector.

• boolean contains(Object elem) testează dacă obiectul specificat este o componentă a acestui vector.

• boolean containsAll(Colecția c) returnează adevărat dacă vectorul conține toate elementele colecției specificate.

• void copyInto(Object[] anArray) copiază componentele acestui vector în tabloul specificat.

• Obiectul elementAt(index int) returnează componenta la indexul specificat.

• Enumeration elements() returnează o enumerare a componentelor acestui vector.

• void assureCapacity(int minCapacity) crește capacitatea acestui vector, dacă este necesar, pentru a se asigura că poate păstra cel puțin numărul de componente dat de argumentul capacității minime.

• boolean equals(Object o) compară obiectul specificat cu acest vector.

• Object firstElement() returnează prima componentă (element la indexul 0) a acestui vector.

• Object get(int index) returnează elementul la poziția specificată în acest vector.

• int hashCode() returnează valoarea codului hash pentru acest vector.

• int indexOf(Object elem) caută prima apariție a argumentului dat, testând egalitatea folosind metoda equals.

• int indexOf(Object elem, int index) caută prima apariție a argumentului dat, începând cu index și testează egalitatea folosind metoda equals.

• void insertElementAt(Object obj, int index) inserează obiectul specificat ca componentă în acest vector la indexul specificat.

• boolean isEmpty() testează acest vector pentru componente lipsă.

• Object lastElement() returnează ultima componentă a vectorului.

• int lastIndexOf(Object elem) returnează indexul ultimei apariții a obiectului specificat în acest vector.

• int lastIndexOf(Object elem, int index) caută înapoi obiectul specificat, începând de la indexul specificat și returnează indexul la acesta.

• Object remove(int index) elimină elementul din poziția specificată în acest vector.

• boolean remove(Object o) elimină prima apariție a elementului specificat în acest vector. Dacă vectorul nu conține un element, acesta nu se modifică.

• boolean removeAll(Colecția c) elimină toate elementele din vector care sunt conținute în Colecția specificată.

• void removeAllElements() elimină toate componentele din vector și setează dimensiunea acestuia la zero.

• boolean removeElement(Object obj) elimină prima apariție (cel mai mic indice) a argumentului din acest vector.

• void removeElementAt(int index) elimină un element din index.

• protected void removeRange(int fromIndex, int toIndex) elimină din această listă toate elementele al căror index este între fromIndex, inclusiv, și toIndex, exclusiv.

• boolean retainAll(Colecția c) reține doar elementele din vector care sunt conținute în Colecția specificată.

• Object set(int index, Object element) înlocuiește elementul din poziția specificată în acest vector cu elementul specificat.

• void setElementAt(Object obj, int index) setează componenta la indexul specificat al acestui vector ca obiect dat.

• void setSize(int newSize) stabilește dimensiunea acestui vector.

• int size() returnează numărul de componente din acest vector.

• List subList(int fromIndex, int toIndex) returnează o reprezentare (vizualizare) a părții din această listă cuprinsă între fromIndex, inclusiv, și toIndex, exclusiv.

• Object[] toArray() returnează o matrice care conține toate elementele acestui vector în ordinea corectă.

• Object[] toArray(Object[] a) returnează un tablou care conține toate elementele acestui vector în ordinea corectă; tipul de execuție al matricei returnate este tipul matricei specificate.

• String toString() returnează o reprezentare șir a acestui vector care conține o reprezentare șir a fiecărui element.

• void trimToSize() reduce capacitatea acestui vector la dimensiunea curentă a vectorului.

Exemplu de vector Java

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());

   }
}

Rezultatul acestui program este mai jos:

Ce este în neregulă cu Vector Class?

Conform documentației clasei Java Vector , dacă nu aveți nevoie de o implementare thread-safe în programul dvs., este recomandat să utilizați ArrayList în loc de Vector (Collection Framework participant mai eficient). Să schimbăm puțin exemplul de mai sus, folosind clasa ArrayList în loc de 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());

       }
   }

Am comentat linia cu vector.indexOf("Johnny", 1) , deoarece nu există o astfel de metodă în această variație în clasa ArrayList . Din același motiv, linia vector.firstElement() a fost comentată. În toate celelalte privințe, programul produce același rezultat ca primul. Desigur, într-un astfel de exemplu, nu este clar de ce ArrayList este mai bun decât Vector . Acest lucru necesită mai multe cunoștințe despre, să zicem, fire. Enumerăm motivele aici. În primul rând, deși clasa Vector este sincronizată, nu poate fi numită complet thread-safe, deși acest lucru pare ciudat. Faptul este că Vector sincronizează fiecare operație, nu întregul Vectorinstanța în sine. Aceasta poate fi o problemă în programele în care trebuie să sincronizați întregul set de operații, mai degrabă decât operațiuni individuale. Să spunem, dacă un fir iterează peste un vector și un alt fir modifică structural o instanță a vectorului, iteratorul va lansa o excepție ConcurrentModificationException . Se pare că două fire de execuție pot funcționa cu o instanță Vector în același timp dacă efectuează operațiuni diferite. În al doilea rând, Vectorulclasa nu are cea mai bună performanță deoarece obiectele sale au o matrice redimensionabilă și o sincronizare. Această combinație înseamnă o suprasarcină suplimentară pentru operațiunile de blocare, indiferent dacă sincronizarea este necesară sau nu. Sigur, acest lucru afectează performanța. În plus, sincronizarea vectorului pentru fiecare operație are, de asemenea, un efect negativ asupra performanței, deoarece vom obține o blocare din nou și din nou pentru fiecare operație. Dacă întreaga instanță a clasei ar fi sincronizată, atunci și blocarea ar fi obținută o dată, ceea ce este mult mai eficient. În al treilea rând, Vector acceptă unele metode vechi. De exemplu, elemente(). Această metodă returnează o enumerare a componentelor vectorului. Programatorii folosesc cel mai adesea Iterator sau ListIterator pentru enumerare și din mai multe motive. În special, Enumeration nu are definită o metodă remove() , ceea ce înseamnă că lista nu poate fi modificată structural în timpul iterației. De asemenea, spre deosebire de ListIterator, Enumeration nu oferă acces bidirecțional. După cum puteți vedea, Vector are destul de multe probleme. Ce se întâmplă dacă mai aveți nevoie de o implementare sigură pentru fire a interfeței List? În acest caz, ArrayList nu va ajuta, dar puteți utiliza, de exemplu, clasa CopyOnWriteArrayList în loc de Vector ; este poziționat ca o variantă thread-safe a ArrayList. De asemenea, puteți sincroniza ArrayList folosind metoda Collections synchronizedList() .

Vector chiar are unele probleme... de ce este încă în Java și de ce ar trebui să fie predat?

Se pune întrebarea: de ce studiem deloc clasa Vector ? Și de ce nu a fost încă eliminat din Java? Faptul este că Java mărturisește principiul compatibilității inverse. Aceasta înseamnă că tot codul vechi scris cu mulți ani în urmă va fi înțeles de versiunile moderne de Java. În plus, există destul de multe aplicații la nivel de întreprindere în mediul Java care au fost suportate de zeci de ani. Este foarte posibil să fii nevoit să te confrunți cu un astfel de „dinozaur” în munca ta, așa că trebuie să fii pregătit pentru surprize, cum ar fi codul cu clase moștenite ineficiente.