Vector-klassen implementerer en række objekter, der kan vokse. Vektorer falder i ældre klasser, men nu er det fuldt kompatibelt med samlinger. Den findes i java.util-pakken og implementere Liste interface, så vi kan bruge alle metoderne i List-grænsefladen som vist nedenfor som følger:

• Vector implementerer et dynamisk array, hvilket betyder, at det kan vokse eller krympe efter behov. Ligesom et array indeholder det komponenter, der kan tilgås ved hjælp af et heltalsindeks.
• De ligner meget ArrayList , men Vector er synkroniseret og har nogle ældre metoder, som samlingsrammerne ikke indeholder.
• Det opretholder også en indsættelsesrækkefølge som en ArrayList. Alligevel bruges den sjældent i et miljø uden tråd, som den er synkroniseret , og på grund af dette giver den en dårlig ydeevne i at tilføje, søge, slette og opdatere dens elementer.
• Iteratorerne, der returneres af Vector-klassen, er fejlhurtige. I tilfælde af samtidig modifikation fejler den og kaster ConcurrentModificationException.

Syntaks:

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

Her, OG er elementtypen.

• Det strækker sig Abstrakt liste og redskaber Liste grænseflader.
• Det implementerer Serializable, Cloneable, Iterable, Collection, List, RandomAccess grænseflader.
• Den direkte kendte underklasse er Stak .

Vigtige punkter vedrørende forøgelsen af ​​vektorkapaciteten er som følger:

Hvis stigningen er angivet, vil Vector udvides i henhold til den i hver tildelingscyklus. Alligevel, hvis stigningen ikke er specificeret, bliver vektorens kapacitet fordoblet i hver tildelingscyklus. Vector definerer tre beskyttede datamedlemmer:

• int kapacitetInkrement: Indeholder stigningsværdien.
• int elementCount: Antal elementer, der i øjeblikket er lagret i vektoren.
• ObjektelementData[]: Array, der holder vektoren, er gemt i den.

Almindelige fejl i erklæringen af ​​vektorer er som følger :

• Vektor kaster en UlovligArgumentundtagelse hvis InitialSize for den definerede vektor er negativ.
• Hvis den angivne samling er null, kaster den NullPointerException .

Konstruktører

1. Vektor(): Opretter en standardvektor med den oprindelige kapacitet er 10.

Vector v = new Vector();>

2. Vektor (int størrelse): Opretter en vektor, hvis startkapacitet er specificeret efter størrelse.

Vector v = new Vector(int size);>

3. Vektor (int størrelse, int incr): Opretter en vektor, hvis indledende kapacitet er specificeret efter størrelse og stigning er specificeret ved incr. Det specificerer antallet af elementer, der skal tildeles, hver gang en vektor skaleres opad.

fang og prøv java

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

4. Vektor (Samling c): Opretter en vektor, der indeholder elementerne i samling c.

Vector v = new Vector(Collection c);>

Metoder i Vector Class

Lad os først diskutere og implementere, hvordan man opretter og bruger en vektor, før vi lander på metoderne i denne klasse.

Eksempel:

// 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 = ny vektor (n); // Tilføjelse af nye elementer ved // slutningen af ​​vektoren for (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>

Bemærk:

• Hvis vektortilvæksten ikke er specificeret, vil dens kapacitet blive fordoblet i hver stigningscyklus.
• Kapaciteten af ​​en vektor kan ikke være under størrelsen, den kan svare til den.

Udførelse af forskellige operationer på Vector-klassen i Java

Lad os diskutere forskellige operationer på Vector-klassen, der er opført som følger:

1. Tilføjelse af elementer
2. Opdatering af elementer
3. Fjernelse af elementer
4. Iteration over elementer

Operation 1: Tilføjelse af elementer

For at tilføje elementerne til vektoren bruger vi tilføje() metode. Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre. De er anført nedenfor som følger:

streng til jsonobject

• tilføje(Objekt): Denne metode bruges til at tilføje et element i slutningen af ​​vektoren.
• add(int index, Object): Denne metode bruges til at tilføje et element ved et specifikt indeks i vektoren.

Eksempel:

// 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 = ny vektor (); // Tilføjelse af brugerdefinerede elementer // ved hjælp af add() metode v2.add(1); v2.add(2); v2.add(3); // Udskrivning af vektorelementerne til konsollen System.out.println('Vektor v2 er ' + v2); } }>

Produktion:

Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3]>

Operation 2: Opdatering af elementer

Efter tilføjelse af elementerne, hvis vi ønsker at ændre elementet, kan det gøres ved hjælp af sæt() metode. Da en vektor er indekseret, refereres det element, som vi ønsker at ændre, af elementets indeks. Derfor kræver denne metode et indeks og det opdaterede element, der skal indsættes ved det indeks.

Eksempel

// 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 = ny vektor (); // Brug add()-metoden til at tilføje elementer i vektoren vec_tor.add(12); vec_tor.add(23); vec_tor.add(22); vec_tor.add(10); vec_tor.add(20); // Viser Vector System.out.println('Vector: ' + vec_tor); // Brug af set()-metoden til at erstatte 12 med 21 System.out.println('Objektet der erstattes er: ' + vec_tor.set(0, 21)); // Brug af set()-metoden til at erstatte 20 med 50 System.out.println('Objektet der erstattes er: ' + vec_tor.set(4, 50)); // Viser den ændrede vektor System.out.println('Den nye vektor er:' + vec_tor); } }>

Vector: [12, 23, 22, 10, 20] The Object that is replaced is: 12 The Object that is replaced is: 20 The new Vector is:[21, 23, 22, 10, 50]>

Operation 3: Fjernelse af elementer

For at fjerne et element fra en vektor kan vi bruge fjerne() metode. Denne metode er overbelastet til at udføre flere operationer baseret på forskellige parametre. De er:

• fjern (objekt): Denne metode bruges til at fjerne et objekt fra vektoren. Hvis der er flere sådanne objekter, fjernes den første forekomst af objektet.
• remove(int index): Da en vektor er indekseret, tager denne metode en heltalsværdi, som blot fjerner elementet, der er til stede ved det specifikke indeks i vektoren. Efter fjernelse af elementet flyttes alle elementer til venstre for at udfylde rummet, og objekternes indekser opdateres.

Eksempel

// 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); } }>

Produktion:

after removal: [1, Geeks, forGeeks, 4]>

Operation 4: Iteration af vektoren

Der er flere måder at iterere gennem vektoren. De mest berømte måder er ved at bruge basic for loop i kombination med en få() metode til at få elementet på et bestemt indeks og avanceret for en løkke .

Eksempel

// 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 = ny vektor(); // Tilføj elementer ved hjælp af add() metoden v.add('Nørder'); v.add('Nørder'); v.add(1, 'For'); // Brug af Get-metoden og // for loop 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 + ' '); } }>

Geeks For Geeks Geeks For Geeks>

Bemærk: Giv en læsning til ArrayList vs Vector klasse i Java at forstå det bedre.

I Java er Vector-klassen en del af Java Collections Framework og giver en dynamisk array-implementering af List-grænsefladen. Det blev tilføjet i den originale udgivelse af Java (Java 1.0) og giver en række metoder til at manipulere elementerne i en vektor, herunder tilføjelse, indsættelse og fjernelse af elementer.

påskeæg i Android

Her er et simpelt eksempel, der viser, hvordan man bruger en vektor i Java:

import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = ny vektor(3, 2); // Tilføj elementer til vektoren v.addElement(1); v.addElement(2); v.addElement(3); // Indsæt et element ved indeks 1 v.insertElementAt(0, 1); // Fjern elementet ved indeks 2 v.removeElementAt(2); // Udskriv vektorens elementer for (int i : v) { System.out.println(i); } } }>

1 0 3>

Bemærk, at Vector-klassen er synkroniseret, hvilket betyder, at flere tråde kan få adgang til den samme vektor uden at forårsage problemer. Denne synkronisering kommer dog på bekostning af ydeevne, så hvis du ikke behøver at dele en vektor mellem flere tråde, er det generelt bedre at bruge en alternativ klasse som ArrayList, som ikke er synkroniseret.

Fordele ved at bruge Vector i Java:

1. Synkronisering: Som nævnt før er Vector synkroniseret, hvilket gør det sikkert at bruge i et multi-threaded miljø.
2. Dynamisk størrelse: Størrelsen af ​​en vektor kan vokse eller krympe dynamisk, efterhånden som elementer tilføjes eller fjernes, så du behøver ikke bekymre dig om at indstille en startstørrelse, der vil rumme alle elementer.
3. Ældre support: Vector har været en del af Java siden starten og understøttes stadig, så det er en god mulighed, hvis du skal arbejde med ældre Java-kode, der bruger Vector.

Ulemper ved at bruge Vector i Java:

1. Ydeevne: Synkroniseringen i Vector kan føre til langsommere ydeevne sammenlignet med andre samlingsklasser, såsom ArrayList.
2. Ældre kode: Mens Vector stadig understøttes, er nyere Java-kode ofte skrevet ved hjælp af de mere moderne samlingsklasser, så det kan være sværere at finde eksempler og support til Vector.
3. Unødvendig overhead: Hvis du ikke har brug for synkroniseringsfunktionerne i Vector, vil brugen af ​​det tilføje unødvendig overhead til din kode.

Opslagsbog

En god opslagsbog til at lære om Java Collections Framework og Vector er Java Collections af Naftalin og Wadler. Denne bog giver et omfattende kig på Java-samlingsrammerne, inklusive Vector, og indeholder mange eksempler og øvelser for at hjælpe dig med at forstå, hvordan du bruger disse klasser effektivt.