Was ist Vector in Java und wie verwenden wir es?

In diesem Blog zu 'Vektoren in Java' erfahren Sie, wie sich die Vektorklasse von ArrayList unterscheidet, und lernen verschiedene Methoden kennen.

Vektoren in sind eine der am häufigsten verwendeten Datenstrukturen in der Programmierwelt.Wir alle wissen das Arrays sind Datenstrukturen, die die Daten linear halten. Vektoren speichern die Daten auch linear, haben jedoch im Gegensatz zu Arrays keine feste Größe. Stattdessen kann ihre Größe bei Bedarf erhöht werden.

Die Vektorklasse ist eine untergeordnete Klasse von AbstractList Klasse und Geräte auf Liste .Um Vektoren zu verwenden, müssen wir zuerst die Vektorklasse aus dem Paket java.util importieren:





importiere java.util.Vector

In diesem Artikel werden wir die folgenden Konzepte von Vektoren diskutieren:



Lass uns anfangen!

Vorteil s von Vector in Java

  • Die Eigenschaft einer dynamischen Größe ist sehr nützlich, da sie die Speicherverschwendung vermeidet, falls wir die Größe der nicht kennen Datenstruktur zum Zeitpunkt der Erklärung.
  • Wenn wir die Größe unserer Datenstruktur mitten in einem Programm ändern möchten, können sich Vektoren als sehr nützlich erweisen.

Die Eigenschaft einer dynamischen Größe gilt nicht nur für Vektoren in Java. Eine andere Datenstruktur, bekannt als ArrayList, zeigt auch die Eigenschaft einer dynamischen Größe. Vektoren unterscheiden sich jedoch aus mehreren Gründen von ArrayLists:

  • Erstens werden Vektoren synchronisiert, was einen Vorteil gegenüber gibt verglichen mit Programme, da das Risiko einer Datenkorruption besteht.
  • Zweitens haben Vektoren einige Legacy-Funktionen, die nur auf Vektoren und nicht auf ArrayLists implementiert werden können.

So greifen Sie auf Elemente in Vector zu

Wir können auf die Datenelemente zugreifen, indem wir einfach den Index des Elements verwenden, genau wie wir auf die Elemente in Arrays zugreifen.



Beispiel- Wenn wir auf das dritte Element in einem Vektor v zugreifen wollen, bezeichnen wir es einfach als v [3].

Vektoren Konstruktoren

Nachfolgend sind die verschiedenen Variationen des Vektors aufgeführt Konstruktoren Zur Verwendung verfügbar:

  1. Vektor (int initialCapacity, int Increment) - Konstruiert einen Vektor mit der angegebenen Anfangskapazität und seiner Größeninkrementierung.
  2. Vektor (int initialCapacity) - - Konstruiert einen leeren Vektor mit der angegebenen initialCapacity. In diesem Fall ist Inkrement Null.
  3. Vektor() - Konstruiert einen Standardvektor der Kapazität 10.
  4. Vektor (Sammlung c) - - Konstruiert einen Vektor mit einer bestimmten Sammlung. Die Reihenfolge der Elemente entspricht der vom Iterator der Sammlung zurückgegebenen.

Es gibt auch drei geschützte Parameter in Vektoren

  1. Int CapacityIncrement () - Es erhöht automatisch die Kapazität des Vektors, wenn die Größe größer als die Kapazität wird.
  2. Int elementCount () - Geben Sie die Anzahl der Elemente im Vektor an
  3. Object [] elementData () - Array, in dem Elemente des Vektors gespeichert sind

Häufigste Fehler bei der Deklaration von Vektoren

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

Hinweis:

  1. Wenn das Vektorinkrement nicht angegeben ist, ist seine Kapazitätin jedem Inkrementzyklus verdoppelt.
  2. Die Kapazität eines Vektors darf nicht unter der Größe liegen, sondern kann dieser entsprechen.

Betrachten wir ein Beispiel für die Initialisierung von Vektorkonstruktoren.

Beispiel: Initialisieren von Vektorkonstruktoren

/ Java-Code zur Veranschaulichung des Imports von Vektorkonstruktoren java.util. * Public class Main {public statisch void main (String [] args) {// Standardvektor erstellen Vektor v1 = neuer Vektor () // Vektor der angegebenen Größe erstellen Vektor v2 = neuer Vektor (20) // erstelle einen Vektor mit gegebener Größe und inkrementiere Vektor v3 = neuer Vektor (30,10) v2.add (100) v2.add (100) v2.add (100) // erstelle einen Vektor mit gegebener Größe Sammlung Vektor v4 = neuer Vektor (v2) System.out.println ('Vektor v1 der Kapazität' + v1.Kapazität ()) System.out.println ('Vektor v2 der Kapazität' + v2.Kapazität ()) System.out .println ('Vektor v3 der Kapazität' + v3.capacity ()) System.out.println ('Vektor v4 der Kapazität' + v4.capacity ())}

Ausgabe

Konstruktoren - Vektoren in Java - Edureka

Speicherzuordnung von Vektoren

Bisher müssen Sie verstanden haben, dass Vektoren keine feste Größe haben, sondern die Möglichkeit haben, ihre Größe dynamisch zu ändern. Man könnte denken, dass die Vektoren unbestimmten langen Speicherplatz zum Speichern von Objekten zuweisen. Dies ist jedoch nicht der Fall. Vektoren können ihre Größe basierend auf zwei Feldern ändern: 'Kapazität' und 'Kapazitätsinkrement'. Bei der Deklaration eines Vektors wird zunächst eine Größe zugewiesen, die dem Feld 'Kapazität' entspricht. Wir können die Elemente einfügen, die der Kapazität entsprechen. Sobald jedoch das nächste Element eingefügt wird, wird das Array um die Größe 'CapacityIncrement' vergrößert. Daher kann es seine Größe dynamisch ändern.

Für ein Standardkonstruktor wird die Kapazität verdoppelt, wenn die Kapazität voll ist und ein neues Element eingefügt werden soll.

Beispiel - Angenommen, wir haben einen Vektor von InitialCapacity 5 und Kapazitätserhöhung Die anfängliche Größe des Vektors beträgt also 5 Elemente. Wir fügen nacheinander 5 Elemente in diesen Vektor ein, nämlich 1,2,3,4,5. Wenn wir versuchen, ein anderes Element in den Vektor einzufügen, nämlich 6, wird die Größe des Vektors um 2 erhöht. Daher ist die Größe des Vektors jetzt 7. Der Vektor passt seine Größe also leicht gemäß der Nr. An. von Elementen.

Ein weiterer interessanter Punkt ist, dass Vektoren im Gegensatz zu Arrays keine realen Objekte enthalten, sondern nur Verweise auf die Objekte. Somit können Objekte unterschiedlicher Datentypen im selben Vektor gespeichert werden.

Methoden im Vektor

Schauen wir uns einige sehr häufig verwendete Vektormethoden an.

Array in C ++ sortieren
  • Boolean add (Objekt o) - Es wird ein Element am Ende des Vektors angehängt.
// Java-Code, der den Import der booleschen add () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) ) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu list v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu System.out.println ('Der Vektor ist' + v)}}

Ausgabe

  • Void add (int Index, E-Element) - Es fügt das angegebene Element am angegebenen Index im Vektor hinzu
// Java-Code, der den Import der void add () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vector v = new Vector () // Erstellt einen Standardvektor v.add (0) , 1) // Fügt 1 am Index hinzu 0 v.add (1, 'Java') // Fügt 'Java' am Index hinzu 1 v.add (2, 'is') // Fügt 'is' am Index hinzu 2 v.add (3, 'Fun') // Fügt 'Fun' am Index hinzu 3 v.add (4, '!!!') // Fügt 'Fun' am Index hinzu 4 System.out.println (' Der Vektor ist '+ v)}}

Ausgabe

  • Boolean Remove (Objekt o) - Es entfernt das Element am angegebenen Index im Vektor
// Java-Code, der den Import der booleschen Methode remove () zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) ) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu list v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu. System.out.println ('Vektor vor dem Entfernen' + v) v.remove (1) System.out.println ('Vektor nach' Entfernung '+ v)}}

Ausgabe

  • Boolean removeElement ( Objekt obj) - - Es löscht das Element mit seinem Namen obj (nicht mit der Indexnummer).
// Java-Code, der den Import der Methode removeElement () zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu. System.out.println ('Vektor vor dem Entfernen' + v) v.removeElement ('Java') System.out.println ('Vector' nach dem Entfernen '+ v)}}

Ausgabe

  • Int size () - Es gibt die Größe des Vektors zurück.
// Java-Code zeigt den Import der size () -Methode java.util. * Public class Main {public statisch void main (String [] args) {Vector v = new Vector () // Erstellt einen Standardvektor v.add (0, 1) // Fügt 1 am Index hinzu 0 v.add (1, 'Java') // Fügt 'Java' am Index 1 hinzu v.add (2, 'is') // Fügt 'is' am Index 2 hinzu v.add (3, 'Fun') // Fügt 'Fun' am Index 3 hinzu. System.out.println ('Die Vektorgröße ist' + v.size ())}}

Ausgabe

  • Int Kapazität () - Es gibt die Kapazität des Vektors zurück
// Java-Code, der den Import der Kapazität () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (0, 1) // Fügt 1 am Index hinzu 0 v.add (1, 'Java') // Fügt 'Java' am Index 1 hinzu v.add (2, 'is') // Fügt 'is' am Index 2 hinzu v.add (3, 'Fun') // Fügt 'Fun' am Index 3 hinzu. System.out.println ('Die Vektorkapazität ist' + v.capacity ())}}

Ausgabe

  • Objekt get (int index) - Es gibt das Element an der angegebenen Position im Vektor zurück
// Java-Code, der den Import der get () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu System.out.println ('Das Element bei Index 1 ist' + v.get (1))}}

Ausgabe

  • Objekt firstElement () - Es gibt das erste Element zurück
// Java-Code, der den Import der firstElement () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu System.out.println ('Das erste Element ist' + v.firstElement ())}}

Ausgabe

  • Objekt lastElement () - Es gibt das letzte Element zurück
// Java-Code, der den Import der lastElement () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (1) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt 'is' am Ende der Liste hinzu v.add ('Fun') // Fügt 'Fun' am Ende der Liste hinzu System.out.println ('Das letzte Element ist' + v.lastElement ())}}

Ausgabe

  • Boolescher Wert gleich (Objekt o) - Es vergleicht den Vektor mit dem angegebenen Objekt auf Gleichheit. Es gibt true zurück, wenn alle Elemente an den entsprechenden Indizes true sind
// Java-Code, der den Import der booleschen equals () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor Vektor vcopy = neuer Vektor () v.add (1) // Fügt 1 am Ende der Liste hinzu v.add ('Java') // Fügt 'Java' am Ende der Liste hinzu v.add ('is') // Fügt hinzu ' ist 'am Ende der Liste v.add (' Fun ') // Fügt' Fun 'am Ende der Liste hinzu vcopy.add (0,1) // Fügt 1 am Index 0 hinzu vcopy.add (1, 'Java') // Fügt 'Java' am Index 1 hinzu vcopy.add (2, 'is') // Fügt 'is' am Index 2 hinzu vcopy.add (3, 'Fun') // Fügt 'Fun' hinzu am Index 3 vcopy.add (4, '!!!') // Fügt 'Spaß' am Index 4 hinzu, wenn (v.equals (vcopy)) System.out.println ('Beide Vektoren sind gleich') else System .out.println ('Vektoren sind nicht gleich')}}

Ausgabe

  • Vimtosize nichtig machen () - Dieses Verfahren entfernt zusätzliche Kapazität und hält die Kapazität nur, um die Elemente zu halten, d. H. Gleich der Größe
// Java-Code, der den Import der trimToSize () -Methode zeigt java.util. * Public class Main {public statisch void main (String [] args) {Vektor v = neuer Vektor () // Erstellt einen Standardvektor v.add (0, 1) // Fügt 1 am Index hinzu 0 v.add (1, 'Java') // Fügt 'Java' am Index 1 hinzu v.add (2, 'is') // Fügt 'is' am Index 2 hinzu v.add (3, 'Fun') // Fügt 'Fun' am Index 3 hinzu. System.out.println ('Die Vektorkapazität ist' + v.capacity ()) v.trimToSize () System.out.println ( 'Die Vektorkapazität ist' + v.capacity ())}}

Ausgabe


Andere Wichtige Methoden

Inzwischen müssen Sie eine gute Vorstellung davon haben, wie man mit Vektoren arbeitet. Wenn Sie mehr über die Vektormethoden erfahren möchten, sehen Sie sich die unten angegebene Tabelle an.

Name der Methode Funktion der Methode

Boolean isEmpty ()

prüft, ob Elemente vorhanden sind oder nicht

Boolescher Wert enthält (Objekt o)

wird verwendet, um die Existenz eines bestimmten Elements zu überprüfen, z. B. o

int indexOf (Objekt o)

Es gibt den Index des Elements o zurück

void removeRange (int s, int e)

entfernt Elemente aus dem Vektor, beginnend mit s und endend mit (e-1)

void clear ()

entfernt alle Elemente

void sureCapacity (int c)

Es erhöht die Kapazität um c

void setSize (int s)

Es setzt die Größe auf s. Wenn die Größe s> ist, wird die zusätzliche Kapazität mit Nullwerten gefüllt. Wenn s

Objekt elementAt (int a)

Gibt das unter Indexnummer a vorhandene Element zurück

Objektmenge (int a, Objekt o)

ersetzt das am Index a vorhandene Element durch das angegebene Element o

Objekt [] toArray ()

Matrix-Multiplikationsprogramm in Java

Gibt ein Array zurück, das dieselben Elemente wie der Vektor enthält

Objektklon ()

Das Vektorobjekt wird kopiert

Boolean addAll (Sammlung c)

Fügt dem Vektor alle Elemente der Sammlung c hinzu

Boolean addAll (int a, Sammlung c)

fügt alle Elemente der Sammlung ein c zum Vektor am angegebenen Index a

Boolean RetainAll (Sammlung c)

behält alle Elemente im Vektor bei, die auch in Sammlung c vorhanden sind

Unterliste auflisten (int s, int e)

Gibt die Elemente als List-Objekt zurück, beginnend mit s und endend mit (e-1) vom Vektor.

Wie alles Gute zu Ende geht, ist auch unser Blog über Vektoren in . Wir hoffen, dass wir in diesem Blog alle Aspekte von Java-Vektoren behandeln konnten und Sie einige Kenntnisse über Vektoren sammeln konnten.

Stellen Sie sicher, dass Sie so viel wie möglich üben und Ihre Erfahrung zurücksetzen.

Besuche die von Edureka, einem vertrauenswürdigen Online-Lernunternehmen mit einem Netzwerk von mehr als 250.000 zufriedenen Lernenden auf der ganzen Welt. Wir sind hier, um Ihnen bei jedem Schritt auf Ihrer Reise zu helfen. Neben diesen Fragen zu Java-Interviews erstellen wir einen Lehrplan, der für Studenten und Fachleute konzipiert ist, die Java-Entwickler werden möchten.

Hast du eine Frage an uns? Bitte erwähnen Sie es im Kommentarbereich dieser 'Vektoren in Java'. Artikel und wir werden uns so schnell wie möglich bei Ihnen melden.