Clasa Vector implementează o serie de obiecte care poate crește. Vectorii se încadrează în clasele moștenite, dar acum este pe deplin compatibil cu colecțiile. Se gaseste in pachetul java.util și implementați Listă interfață, astfel încât să putem folosi toate metodele interfeței Listă, după cum se arată mai jos, după cum urmează:

• Vector implementează o matrice dinamică, ceea ce înseamnă că poate crește sau micșora după cum este necesar. Ca o matrice, conține componente care pot fi accesate folosind un index întreg.
• Sunt foarte asemănătoare cu ArrayList , dar Vector este sincronizat și are unele metode moștenite pe care cadrul de colecție nu le conține.
• De asemenea, menține o ordine de inserare ca un ArrayList. Cu toate acestea, este rar folosit într-un mediu fără fire așa cum este sincronizate , și datorită acestui fapt, oferă o performanță slabă în adăugarea, căutarea, ștergerea și actualizarea elementelor sale.
• Iteratoarele returnate de clasa Vector sunt rapide. În cazul modificării concurente, eșuează și aruncă ConcurrentModificationException.

Sintaxă:

public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable>

Aici, ȘI este tipul de element.

• Se extinde AbstractList și instrumente Listă interfețe.
• Implementează interfețele Serializabile, Clonabile, Iterabile, Colecție, Listă, RandomAccess.
• Subclasa direct cunoscută este Grămadă .

Punctele importante privind creșterea capacității vectoriale sunt următoarele:

Dacă se specifică incrementul, Vector se va extinde în funcție de acesta în fiecare ciclu de alocare. Totuși, dacă incrementul nu este specificat, atunci capacitatea vectorului se dublează în fiecare ciclu de alocare. Vector definește trei membri de date protejați:

• int Capacitate Increment: Conține valoarea de increment.
• int elementCount: Numărul de elemente în prezent în vector stocate în acesta.
• Object elementData[]: Matricea care deține vectorul este stocată în el.

Erorile comune în declarația Vectorilor sunt ca urmează :

• Vector aruncă o IllegalArgumentException dacă InitialSize a vectorului definit este negativ.
• Dacă colecția specificată este nulă, se aruncă NullPointerException .

Constructorii

1. Vector (): Creează un vector implicit al capacității inițiale 10.

Vector v = new Vector();>

2. Vector (dimensiune int): Creează un vector a cărui capacitate inițială este specificată de dimensiune.

Vector v = new Vector(int size);>

3. Vector (int size, int incr): Creează un vector a cărui capacitate inițială este specificată prin dimensiune și increment este specificată prin incr. Specifică numărul de elemente de alocat de fiecare dată când un vector este redimensionat în sus.

imprimare javascript

Vector v = new Vector(int size, int incr);>

4. Vector (Colecția c): Creează un vector care conține elementele colecției c.

Vector v = new Vector(Collection c);>

Metode în Clasa Vector

Să discutăm și să implementăm mai întâi cum să creăm și să folosim un Vector înainte de a ajunge la metodele acestei clase.

Exemplu:

// Java Program to Demonstrate Working of Vector // Via Creating and Using It // Importing required classes import java.io.*; import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Size of the Vector int n = 5; // Declaring the Vector with // initial size n Vector v = vector nou (n); // Adăugarea de elemente noi la // sfârșitul vectorului pentru (int i = 1; i<= n; i++) v.add(i); // Printing elements System.out.println(v); // Remove element at index 3 v.remove(3); // Displaying the vector // after deletion System.out.println(v); // iterating over vector elements // using for loop for (int i = 0; i < v.size(); i++) // Printing elements one by one System.out.print(v.get(i) + ' '); } }>

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

Notă:

• Dacă incrementul vectorial nu este specificat, atunci capacitatea sa va fi dublată în fiecare ciclu de increment.
• Capacitatea unui vector nu poate fi sub dimensiunea, poate fi egală cu aceasta.

Efectuarea diferitelor operații pe clasa Vector în Java

Să discutăm diferite operații pe clasa Vector care sunt enumerate după cum urmează:

1. Adăugarea de elemente
2. Elemente de actualizare
3. Îndepărtarea elementelor
4. Iterarea peste elemente

Operațiunea 1: Adăugarea de elemente

şacal vs lup

Pentru a adăuga elemente la Vector, folosim adăuga() metodă. Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri. Acestea sunt enumerate mai jos, după cum urmează:

• adauga (Obiect): Această metodă este folosită pentru a adăuga un element la sfârșitul Vectorului.
• add(int index, Object): Această metodă este folosită pentru a adăuga un element la un index specific în Vector.

Exemplu:

// Java Program to Add Elements in Vector Class // Importing required classes import java.io.*; import java.util.*; // Main class // AddElementsToVector class GFG { // Main driver method public static void main(String[] arg) { // Case 1 // Creating a default vector Vector v1 = new Vector(); // Adding custom elements // using add() method v1.add(1); v1.add(2); v1.add('geeks'); v1.add('forGeeks'); v1.add(3); // Printing the vector elements to the console System.out.println('Vector v1 is ' + v1); // Case 2 // Creating generic vector Vector v2 = vector nou (); // Adăugarea elementelor personalizate // folosind metoda add() v2.add(1); v2.add(2); v2.add(3); // Tipărirea elementelor vectoriale pe consolă System.out.println('Vector v2 este ' + v2); } }>>> 
     Ieșire:    
 
 
 
  
 
 
Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3]>
 
    Operațiunea 2:         Actualizarea elementelor    
 
După adăugarea elementelor, dacă dorim să schimbăm elementul, se poate face folosind funcția a stabilit() metodă. Deoarece un Vector este indexat, elementul pe care dorim să-l schimbăm este referit de indexul elementului. Prin urmare, această metodă necesită un index și elementul actualizat să fie inserat la acel index.
 
    Exemplu    
Java 
// Java code to change the // elements in vector class import java.util.*; // Driver Class public class UpdatingVector { // Main Function public static void main(String args[]) { // Creating an empty Vector Vector vec_tor = vector nou (); // Folosește metoda add() pentru a adăuga elemente în vectorul vec_tor.add(12); vector_tor.add(23); vector_tor.add(22); vector_tor.add(10); vector_tor.add(20); // Afișarea sistemului vectorial.out.println('Vector: ' + vec_tor); // Folosind metoda set() pentru a înlocui 12 cu 21 System.out.println('Obiectul care este înlocuit este: ' + vec_tor.set(0, 21)); // Folosind metoda set() pentru a înlocui 20 cu 50 System.out.println('Obiectul care este înlocuit este: ' + vec_tor.set(4, 50)); // Afișarea vectorului modificat System.out.println('Noul vector este:' + vec_tor); } }>>>  
  Ieșire      Operațiunea 3:         Îndepărtarea elementelor    
 
Pentru a elimina un element dintr-un Vector, putem folosi elimina() metodă. Această metodă este supraîncărcată pentru a efectua mai multe operații bazate pe diferiți parametri. Sunt:
 
    elimina (Obiect):    Această metodă este folosită pentru a elimina un obiect din Vector. Dacă există mai multe astfel de obiecte, atunci prima apariție a obiectului este eliminată.
    elimina (index int):    Deoarece un Vector este indexat, această metodă ia o valoare întreagă care pur și simplu elimină elementul prezent la acel index specific din Vector. După eliminarea elementului, toate elementele sunt mutate spre stânga pentru a umple spațiul și indicii obiectelor sunt actualizați.
    Exemplu    
Java 
// Java code illustrating the removal // of elements from vector import java.util.*; import java.io.*; class RemovingElementsFromVector { public static void main(String[] arg) { // Create default vector of capacity 10 Vector v = new Vector(); // Add elements using add() method v.add(1); v.add(2); v.add('Geeks'); v.add('forGeeks'); v.add(4); // Removing first occurrence element at 1 v.remove(1); // Checking vector System.out.println('after removal: ' + v); } }>
  
     Ieșire:    
     Operația 4: Iterarea vectorului    
 
Există mai multe moduri de a itera prin Vector. Cele mai cunoscute moduri sunt folosirea buclei for de bază în combinație cu a obține() metoda de a obține elementul la un index specific și  avansat pentru o buclă  .
 
    Exemplu    
format data în șir
Java 
// Java program to iterate the elements // in a Vector import java.util.*; public class IteratingVector { public static void main(String args[]) { // create an instance of vector Vectorv = vector nou(); // Adăugați elemente folosind metoda add() v.add('Geeks'); v.add('Geeks'); v.add(1, 'Pentru'); // Folosind metoda Get și bucla // for for (int i = 0; i< v.size(); i++) { System.out.print(v.get(i) + ' '); } System.out.println(); // Using the for each loop for (String str : v) System.out.print(str + ' '); } }>
   
  Ieșire  
Geeks For Geeks Geeks For Geeks>
  
    Notă:    Dați o citire la Clasa ArrayList vs Vector în Java să-l înțeleg mai bine.
 
În Java, clasa Vector este o parte a Java Collections Framework și oferă o implementare dinamică a matricei a interfeței List. A fost adăugat în versiunea originală a Java (Java 1.0) și oferă o serie de metode pentru manipularea elementelor unui vector, inclusiv adăugarea, inserarea și eliminarea elementelor.
 
Iată un exemplu simplu care demonstrează cum se utilizează un vector în Java:
Java 
import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = vector nou (3, 2); // Adăugați elemente la vectorul v.addElement(1); v.addElement(2); v.addElement(3); // Se introduce un element la indexul 1 v.insertElementAt(0, 1); // Eliminați elementul de la indexul 2 v.removeElementAt(2); // Imprimă elementele vectorului pentru (int i : v) { System.out.println(i); } } }>>>  
  Ieșire  Rețineți că clasa Vector este sincronizată, ceea ce înseamnă că mai multe fire pot accesa același vector fără a cauza probleme. Cu toate acestea, această sincronizare vine cu prețul performanței, așa că dacă nu trebuie să partajați un vector între mai multe fire de execuție, este, în general, mai bine să utilizați o clasă alternativă, cum ar fi ArrayList, care nu este sincronizată.
 
Avantajele utilizării Vector în Java:
Sincronizare: După cum sa menționat anterior, Vector este sincronizat, ceea ce îl face sigur de utilizat într-un mediu cu mai multe fire.
Dimensiune dinamică: dimensiunea unui vector poate crește sau micșora dinamic pe măsură ce elementele sunt adăugate sau eliminate, astfel încât nu trebuie să vă faceți griji cu privire la setarea unei dimensiuni inițiale care să găzduiască toate elementele.
Suport vechi: Vector a făcut parte din Java încă de la început și este încă acceptat, așa că este o opțiune bună dacă trebuie să lucrați cu cod Java mai vechi care folosește Vector.
Dezavantajele utilizării Vector în Java:
Performanță: Sincronizarea în Vector poate duce la o performanță mai lentă în comparație cu alte clase de colecție, cum ar fi ArrayList.
Cod moștenit: deși Vector este încă acceptat, codul Java mai nou este adesea scris folosind clasele de colecție mai moderne, așa că poate fi mai greu să găsiți exemple și suport pentru Vector.
Suprafață inutilă: dacă nu aveți nevoie de caracteristicile de sincronizare ale Vector, utilizarea acestuia va adăuga un cost suplimentar inutil la codul dvs.
Carte de referinta
O carte de referință bună pentru a afla despre Cadrul și Vectorul colecțiilor Java este Colecțiile Java de Naftalin și Wadler. Această carte oferă o privire cuprinzătoare asupra cadrului colecțiilor Java, inclusiv Vector, și include multe exemple și exerciții pentru a vă ajuta să înțelegeți cum să utilizați aceste clase în mod eficient.