Die Vector-Klasse implementiert ein erweiterbares Array von Objekten. Vektoren fallen in Legacy-Klassen, sind aber jetzt vollständig mit Sammlungen kompatibel. Es findet sich in java.util-Paket und umsetzen Aufführen Schnittstelle, sodass wir alle Methoden der List-Schnittstelle wie unten gezeigt wie folgt verwenden können:

• Vector implementiert ein dynamisches Array, das heißt, es kann je nach Bedarf vergrößert oder verkleinert werden. Es enthält wie ein Array Komponenten, auf die über einen ganzzahligen Index zugegriffen werden kann.
• Sie sind sehr ähnlich Anordnungsliste , aber Vector ist synchronisiert und verfügt über einige Legacy-Methoden, die das Sammlungsframework nicht enthält.
• Es verwaltet auch eine Einfügereihenfolge wie eine ArrayList. Dennoch wird es so wie es ist selten in einer Nicht-Thread-Umgebung verwendet synchronisiert , und aus diesem Grund ist die Leistung beim Hinzufügen, Suchen, Löschen und Aktualisieren seiner Elemente schlecht.
• Die von der Vector-Klasse zurückgegebenen Iteratoren sind ausfallsicher. Im Falle einer gleichzeitigen Änderung schlägt es fehl und wirft das ConcurrentModificationException.

Syntax:

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

Hier, UND ist der Typ des Elements.

• Es erstreckt sich AbstractList und implementiert Aufführen Schnittstellen.
• Es implementiert serialisierbare, klonbare, iterierbare, Sammlungs-, Listen- und RandomAccess-Schnittstellen.
• Die direkt bekannte Unterklasse ist Stapel .

Wichtige Punkte bezüglich der Erhöhung der Vektorkapazität sind wie folgt:

Wenn das Inkrement angegeben ist, wird Vector in jedem Zuordnungszyklus entsprechend erweitert. Wenn das Inkrement jedoch nicht angegeben wird, wird die Kapazität des Vektors in jedem Zuweisungszyklus verdoppelt. Vector definiert drei geschützte Datenelemente:

• int CapacityInkrement: Enthält den Inkrementwert.
• int elementCount: Anzahl der aktuell im Vektor gespeicherten Elemente.
• ObjektelementData[]: Darin wird ein Array gespeichert, das den Vektor enthält.

Häufige Fehler bei der Deklaration von Vektoren sind: folgt :

• Vector wirft eine IllegalArgumentException wenn die InitialSize des definierten Vektors negativ ist.
• Wenn die angegebene Sammlung null ist, wird sie ausgelöst NullPointerException .

Konstrukteure

1. Vektor(): Erstellt einen Standardvektor mit der Anfangskapazität von 10.

Vector v = new Vector();>

2. Vektor (int-Größe): Erstellt einen Vektor, dessen Anfangskapazität durch die Größe angegeben wird.

Vector v = new Vector(int size);>

3. Vektor(int size, int incr): Erstellt einen Vektor, dessen Anfangskapazität durch Größe und Inkrement durch Inkr angegeben wird. Es gibt die Anzahl der Elemente an, die jedes Mal zugewiesen werden, wenn die Größe eines Vektors nach oben geändert wird.

was ist 10 von 60

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

4. Vektor (Sammlung c): Erstellt einen Vektor, der die Elemente der Sammlung c enthält.

Wie alt ist Pete Davidson?

Vector v = new Vector(Collection c);>

Methoden in der Vektorklasse

Lassen Sie uns zunächst besprechen und implementieren, wie ein Vektor erstellt und verwendet wird, bevor wir uns den Methoden dieser Klasse zuwenden.

Beispiel:

// 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 = neuer Vektor (N); // Anhängen neuer Elemente // am Ende des Vektors 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>

Notiz:

• Wenn das Vektorinkrement nicht angegeben ist, wird seine Kapazität in jedem Inkrementierungszyklus verdoppelt.
• Die Kapazität eines Vektors kann nicht kleiner als die Größe sein, sie kann dieser Größe entsprechen.

Durchführen verschiedener Operationen an der Vektorklasse in Java

Lassen Sie uns verschiedene Operationen für die Vektorklasse besprechen, die wie folgt aufgeführt sind:

1. Elemente hinzufügen
2. Elemente aktualisieren
3. Elemente entfernen
4. Iterieren über Elemente

Vorgang 1: Elemente hinzufügen

Um die Elemente zum Vektor hinzuzufügen, verwenden wir die hinzufügen() Methode. Diese Methode ist überladen, um mehrere Vorgänge basierend auf unterschiedlichen Parametern auszuführen. Sie sind nachfolgend wie folgt aufgeführt:

• add(Objekt): Mit dieser Methode wird am Ende des Vektors ein Element hinzugefügt.
• add(int index, Object): Mit dieser Methode wird ein Element an einem bestimmten Index im Vektor hinzugefügt.

Beispiel:

Java-String anhängen

// 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 = neuer Vektor (); // Benutzerdefinierte Elemente hinzufügen // mit der add()-Methode v2.add(1); v2.add(2); v2.add(3); // Drucken der Vektorelemente auf der Konsole System.out.println('Vector v2 is ' + v2); } }>

Ausgabe:

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

Vorgang 2: Elemente aktualisieren

Wenn wir nach dem Hinzufügen der Elemente das Element ändern möchten, können wir dies mit dem tun Satz() Methode. Da ein Vektor indiziert ist, wird das Element, das wir ändern möchten, durch den Index des Elements referenziert. Daher benötigt diese Methode einen Index und das aktualisierte Element, das an diesem Index eingefügt werden soll.

Beispiel

// 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 = neuer Vektor (); // Verwenden Sie die Methode add(), um Elemente im Vektor hinzuzufügen vec_tor.add(12); vec_tor.add(23); vec_tor.add(22); vec_tor.add(10); vec_tor.add(20); // Den Vektor anzeigen System.out.println('Vector: ' + vec_tor); // Mit der Methode set() 12 durch 21 ersetzen System.out.println('Das zu ersetzende Objekt ist: ' + vec_tor.set(0, 21)); // Mit der Methode set() 20 durch 50 ersetzen System.out.println('Das Objekt, das ersetzt wird, ist: ' + vec_tor.set(4, 50)); // Anzeige des geänderten Vektors System.out.println('Der neue Vektor ist:' + 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]>

Vorgang 3: Elemente entfernen

wie man einen Zeiger in c dereferenziert

Um ein Element aus einem Vektor zu entfernen, können wir Folgendes verwenden entfernen() Methode. Diese Methode ist überladen, um mehrere Vorgänge basierend auf unterschiedlichen Parametern auszuführen. Sie sind:

• entfernen(Objekt): Mit dieser Methode wird ein Objekt aus dem Vektor entfernt. Wenn mehrere solcher Objekte vorhanden sind, wird das erste Vorkommen des Objekts entfernt.
• entfernen(int index): Da ein Vektor indiziert ist, nimmt diese Methode einen ganzzahligen Wert an, der einfach das Element entfernt, das an diesem bestimmten Index im Vektor vorhanden ist. Nach dem Entfernen des Elements werden alle Elemente nach links verschoben, um den Platz zu füllen, und die Indizes der Objekte werden aktualisiert.

Beispiel

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

Ausgabe:

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

Operation 4: Iterieren des Vektors

Es gibt mehrere Möglichkeiten, den Vektor zu durchlaufen. Die bekanntesten Methoden sind die Verwendung der einfachen for-Schleife in Kombination mit a erhalten() Methode, um das Element an einem bestimmten Index abzurufen und die für eine Schleife erweitert .

Beispiel

// 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 = neuer Vektor(); // Elemente mit der Methode add() hinzufügen v.add('Geeks'); v.add('Geeks'); v.add(1, 'For'); // Mit der Get-Methode und der // for-Schleife 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>

Notiz: Lesen Sie die ArrayList vs. Vector-Klasse in Java um es besser zu begreifen.

In Java ist die Vector-Klasse Teil des Java Collections Framework und stellt eine dynamische Array-Implementierung der List-Schnittstelle bereit. Es wurde in der Originalversion von Java (Java 1.0) hinzugefügt und bietet eine Reihe von Methoden zum Bearbeiten der Elemente eines Vektors, einschließlich des Hinzufügens, Einfügens und Entfernens von Elementen.

Hier ist ein einfaches Beispiel, das zeigt, wie ein Vektor in Java verwendet wird:

import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = neuer Vektor(3, 2); // Elemente zum Vektor hinzufügen v.addElement(1); v.addElement(2); v.addElement(3); // Ein Element bei Index 1 einfügen v.insertElementAt(0, 1); // Element bei Index 2 entfernen v.removeElementAt(2); // Elemente des Vektors drucken for (int i : v) { System.out.println(i); } } }>

1 0 3>

Beachten Sie, dass die Vector-Klasse synchronisiert ist, was bedeutet, dass mehrere Threads problemlos auf denselben Vektor zugreifen können. Diese Synchronisierung geht jedoch zu Lasten der Leistung. Wenn Sie also keinen Vektor zwischen mehreren Threads teilen müssen, ist es im Allgemeinen besser, eine alternative Klasse wie ArrayList zu verwenden, die nicht synchronisiert ist.

Vorteile der Verwendung von Vector in Java:

1. Synchronisierung: Wie bereits erwähnt, ist Vector synchronisiert, sodass die Verwendung in einer Multithread-Umgebung sicher ist.
2. Dynamische Größe: Die Größe eines Vektors kann dynamisch wachsen oder schrumpfen, wenn Elemente hinzugefügt oder entfernt werden. Sie müssen sich also nicht darum kümmern, eine Anfangsgröße festzulegen, die allen Elementen gerecht wird.
3. Legacy-Unterstützung: Vector ist seit seiner Einführung Teil von Java und wird immer noch unterstützt. Daher ist es eine gute Option, wenn Sie mit älterem Java-Code arbeiten müssen, der Vector verwendet.

Nachteile der Verwendung von Vector in Java:

1. Leistung: Die Synchronisierung in Vector kann zu einer langsameren Leistung im Vergleich zu anderen Sammlungsklassen wie ArrayList führen.
2. Legacy-Code: Vector wird weiterhin unterstützt, neuerer Java-Code wird jedoch häufig mit den moderneren Sammlungsklassen geschrieben, sodass es möglicherweise schwieriger ist, Beispiele und Unterstützung für Vector zu finden.
3. Unnötiger Overhead: Wenn Sie die Synchronisierungsfunktionen von Vector nicht benötigen, führt die Verwendung von Vector zu unnötigem Overhead für Ihren Code.

Nachschlagewerk

Ein gutes Nachschlagewerk zum Erlernen des Java Collections Framework und Vector ist Java Collections von Naftalin und Wadler. Dieses Buch bietet einen umfassenden Einblick in das Java-Collections-Framework, einschließlich Vector, und enthält viele Beispiele und Übungen, die Ihnen helfen, zu verstehen, wie Sie diese Klassen effektiv nutzen.