Java-Vektor

Wahrscheinlich sind Sie in Java bereits auf Arrays gestoßen und wissen, dass einer ihrer Hauptnachteile die Größenkonstanz ist. Sobald Sie ein Array mit einer bestimmten Größe erstellt haben, können Sie diese später nicht mehr ändern. Es gibt mehrere Java Collection-Framework-Klassen in der Java-Sprache, die dieses Problem lösen. Eine davon ist die Java Vector Class. Es wird in diesem Artikel besprochen.

Was ist die Vektorklasse?

Wie wir im Vorwort geschrieben haben, beseitigt die Vector- Klasse des Java Collection Framework das Problem der statischen Größe von Arrays. Java Vector ist eine Art dynamisches Array und kann vergrößert oder verkleinert werden. Mit der Vector- Sammlungsklasse können wir eine Gruppe von Elementen als einfache Objekte speichern und sie mit den verschiedenen Methoden manipulieren. Die Vector-Klasse ist im Paket java.util verfügbar . Daher kann Vector in Java verwendet werden, wenn Sie die Größe des Arrays nicht im Voraus kennen oder wenn Sie ein „Array“ benötigen, dessen Abmessungen sich im Laufe der Lebensdauer des Programms ändern können. Es muss gleich gesagt werden, dass der VectorDie Klasse ist bereits ziemlich alt, und später erschienen Sammlungen, die sie in den allermeisten Fällen ersetzen können. Das beliebte „Analogon“ von Java Vector ist die ArrayList- Klasse. Der wichtigste Unterschied zwischen diesen Klassen besteht darin, dass Vector synchronisiert ist, ArrayList jedoch nicht. Über weitere Unterschiede zwischen diesen beiden Klassen und moderneren Analoga der Vector- Klasse sprechen wir etwas später im Abschnitt „Was stimmt mit der Vector-Klasse nicht?“.

Java-Vektormethoden

Hier sind Java- Vektormethoden :

• void add(int index, Object element) fügt das angegebene Element an der angegebenen Position des Vektors ein.

• boolean add(Object o) fügt das angegebene Element am Ende des Vektors hinzu.

• boolean addAll(Collection c) fügt alle Elemente in der angegebenen Sammlung am Ende des Vektors in der Reihenfolge hinzu, in der sie vom angegebenen Sammlungsiterator zurückgegeben werden.

• boolean addAll(int index, Collection c) fügt alle Elemente innerhalb der angegebenen Collection an der angegebenen Position in den Vektor ein.

• void addElement(Object obj) fügt die angegebene Komponente am Ende dieses Vektors hinzu und erhöht seine Größe um eins.

• int Capacity() gibt die aktuelle Kapazität dieses Vektors zurück.

• void clear() entfernt alle Elemente aus diesem Vektor.

• Object clone() gibt einen Klon dieses Vektors zurück.

• boolean contains(Object elem) testet, ob das angegebene Objekt eine Komponente in diesem Vektor ist.

• boolean containsAll(Collection c) gibt true zurück, wenn der Vektor alle Elemente der angegebenen Collection enthält.

• void copyInto(Object[] anArray) kopiert die Komponenten dieses Vektors in das angegebene Array.

• Das Objekt elementAt(int index) gibt die Komponente am angegebenen Index zurück.

• Enumeration elements() gibt eine Aufzählung der Komponenten dieses Vektors zurück.

• void secureCapacity(int minCapacity) erhöht bei Bedarf die Kapazität dieses Vektors, um sicherzustellen, dass er mindestens die durch das Argument der minimalen Kapazität angegebene Anzahl an Komponenten aufnehmen kann.

• boolean equal(Object o) vergleicht das angegebene Objekt mit diesem Vektor.

• Das Objekt firstElement() gibt die erste Komponente (Element bei Index 0) dieses Vektors zurück.

• Das Objekt get(int index) gibt das Element an der angegebenen Position in diesem Vektor zurück.

• int hashCode() gibt den Hash-Codewert für diesen Vektor zurück.

• int indexOf(Object elem) sucht nach dem ersten Vorkommen des angegebenen Arguments und prüft die Gleichheit mithilfe der Methode equal.

• int indexOf(Object elem, int index) sucht nach dem ersten Vorkommen des angegebenen Arguments, beginnend beim Index, und prüft die Gleichheit mithilfe der Methode equal.

• void insertElementAt(Object obj, int index) fügt das angegebene Objekt als Komponente am angegebenen Index in diesen Vektor ein.

• boolean isEmpty() testet diesen Vektor auf fehlende Komponenten.

• Das Objekt lastElement() gibt die letzte Komponente des Vektors zurück.

• int lastIndexOf(Object elem) gibt den Index des letzten Vorkommens des angegebenen Objekts in diesem Vektor zurück.

• int lastIndexOf(Object elem, int index) sucht rückwärts nach dem angegebenen Objekt, beginnend am angegebenen Index, und gibt den Index dafür zurück.

• Das Objekt „remove(int index)“ entfernt das Element an der angegebenen Position in diesem Vektor.

• boolean remove(Object o) entfernt das erste Vorkommen des angegebenen Elements in diesem Vektor. Wenn der Vektor kein Element enthält, ändert er sich nicht.

• boolean removeAll(Collection c) entfernt alle Elemente aus dem Vektor, die in der angegebenen Collection enthalten sind.

• void removeAllElements() entfernt alle Komponenten aus dem Vektor und setzt seine Größe auf Null.

• boolean removeElement(Object obj) entfernt das erste Vorkommen (niedrigster Index) des Arguments aus diesem Vektor.

• void removeElementAt(int index) entfernt ein Element am Index.

• protected void removeRange(int fromIndex, int toIndex) entfernt aus dieser Liste alle Elemente, deren Index zwischen fromIndex (inklusive) und toIndex (exklusiv) liegt.

• boolean retainAll(Collection c) behält nur die Elemente im Vektor bei, die in der angegebenen Collection enthalten sind.

• Object set(int index, Object element) ersetzt das Element an der angegebenen Position in diesem Vektor durch das angegebene Element.

• void setElementAt(Object obj, int index) setzt die Komponente am angegebenen Index dieses Vektors als gegebenes Objekt.

• void setSize(int newSize) legt die Größe dieses Vektors fest.

• int size() gibt die Anzahl der Komponenten in diesem Vektor zurück.

• List subList(int fromIndex, int toIndex) gibt eine Darstellung (Ansicht) des Teils dieser Liste zwischen fromIndex (inklusive) und toIndex (exklusiv) zurück.

• Object[] toArray() gibt ein Array zurück, das alle Elemente dieses Vektors in der richtigen Reihenfolge enthält.

• Object[] toArray(Object[] a) gibt ein Array zurück, das alle Elemente dieses Vektors in der richtigen Reihenfolge enthält; Der Ausführungstyp des zurückgegebenen Arrays ist der Typ des angegebenen Arrays.

• String toString() gibt eine String-Darstellung dieses Vektors zurück, die eine String-Darstellung jedes Elements enthält.

• void trimToSize() trimmt die Kapazität dieses Vektors auf die aktuelle Größe des Vektors.

Beispiel für einen Java-Vektor

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

   }
}

Die Ausgabe dieses Programms ist hier unten:

Was ist los mit der Vector-Klasse?

Laut der Dokumentation der Java Vector- Klasse wird empfohlen, ArrayList anstelle von Vector zu verwenden (Collection Framework effektiverer Teilnehmer), wenn Sie keine Thread-sichere Implementierung in Ihrem Programm benötigen. Lassen Sie uns das obige Beispiel ein wenig ändern und die Klasse ArrayList anstelle von Vector verwenden .

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

       }
   }

Wir haben die Zeile mit vector.indexOf("Johnny", 1) auskommentiert , da es in dieser Variante der ArrayList- Klasse keine solche Methode gibt. Aus dem gleichen Grund wurde die Zeile vector.firstElement() auskommentiert. Im Übrigen liefert das Programm das gleiche Ergebnis wie das erste. Natürlich ist in einem solchen Beispiel nicht klar, warum ArrayList besser ist als Vector . Dies erfordert mehr Wissen beispielsweise über Threads. Die Gründe listen wir hier auf. Erstens: Obwohl die Vector- Klasse synchronisiert ist, kann sie nicht als vollständig threadsicher bezeichnet werden, obwohl dies seltsam erscheint. Tatsache ist, dass Vector jede Operation synchronisiert, nicht den gesamten VectorInstanz selbst. Dies kann in Programmen ein Problem sein, in denen Sie den gesamten Satz von Vorgängen und nicht einzelne Vorgänge synchronisieren müssen. Wenn beispielsweise ein Thread über einen Vektor iteriert und ein anderer Thread eine Instanz des Vektors strukturell ändert, löst der Iterator eine ConcurrentModificationException aus . Es stellt sich heraus, dass zwei Threads gleichzeitig mit einer Vector- Instanz arbeiten können, wenn sie unterschiedliche Operationen ausführen. Zweitens der VektorDie Klasse weist nicht die beste Leistung auf, da ihre Objekte über ein in der Größe veränderbares Array und eine Synchronisierung verfügen. Diese Kombination bedeutet zusätzlichen Overhead für Blockierungsvorgänge, unabhängig davon, ob eine Synchronisierung erforderlich ist oder nicht. Sicher, das wirkt sich auf die Leistung aus. Darüber hinaus wirkt sich die Synchronisierung des Vektors bei jeder Operation auch negativ auf die Leistung aus, da wir für jede Operation immer wieder eine Sperre erwerben. Wenn die gesamte Instanz der Klasse synchronisiert wäre, würde die Sperre auch einmal erworben werden, was viel effizienter ist. Drittens unterstützt Vector einige Legacy-Methoden. Zum Beispiel elements(). Diese Methode gibt eine Aufzählung der Komponenten des Vektors zurück. Programmierer verwenden aus mehreren Gründen am häufigsten Iterator oder ListIterator für die Aufzählung. Insbesondere ist für Enumeration keine Methode „remove()“ definiert, was bedeutet, dass die Liste während der Iteration nicht strukturell geändert werden kann. Außerdem bietet Enumeration im Gegensatz zu ListIterator keinen bidirektionalen Zugriff. Wie Sie sehen, hat Vector einige Probleme. Was ist, wenn Sie weiterhin eine threadsichere Implementierung der List-Schnittstelle benötigen? In diesem Fall hilft ArrayList nicht, aber Sie können beispielsweise die Klasse CopyOnWriteArrayList anstelle von Vector verwenden ; Es ist als threadsichere Variante der ArrayList positioniert. Sie können ArrayList auch mit der Methode Collections synchronisiertList() synchronisieren .

Vector hat wirklich einige Probleme ... warum ist es immer noch in Java und warum sollte es gelehrt werden?

Es stellt sich die Frage: Warum studieren wir überhaupt die Vector- Klasse? Und warum wurde es noch nicht aus Java entfernt? Tatsache ist, dass Java das Prinzip der Abwärtskompatibilität bekennt. Dies bedeutet, dass der gesamte alte Code, der vor vielen Jahren geschrieben wurde, von modernen Java-Versionen verstanden wird. Darüber hinaus gibt es im Java-Umfeld eine ganze Reihe von Unternehmensanwendungen, die seit Jahrzehnten unterstützt werden. Es ist durchaus möglich, dass Sie bei Ihrer Arbeit mit einem solchen „Dinosaurier“ zu tun haben, daher müssen Sie auf Überraschungen vorbereitet sein, beispielsweise auf Code mit ineffektiven Legacy-Klassen.