Java-vector

Waarschijnlijk bent u al arrays tegengekomen in Java en weet u dat een van hun grootste nadelen de constantheid van de grootte is. Als je eenmaal een array van een bepaalde grootte hebt gemaakt, kun je die later niet meer wijzigen. Er zijn verschillende Java Collection-frameworkklassen in de Java-taal die dit probleem oplossen. Een daarvan is Java Vector Class. Het zal in dit artikel worden besproken.

Wat is vectorklasse

Zoals we in het voorwoord schreven, elimineert de Vector- klasse van Java Collection Framework het probleem van de statische grootte van arrays. Java Vector is een soort dynamische array en kan in omvang groeien of krimpen. Met behulp van de Vector- verzamelingsklasse kunnen we een groep elementen opslaan als eenvoudige objecten en deze op verschillende manieren manipuleren. De klasse Vector is beschikbaar in het pakket java.util . Vector in Java kan dus worden gebruikt als u de grootte van de array niet van tevoren weet, of als u een "array" nodig hebt die de dimensies tijdens de levensduur van het programma kan veranderen. Het moet meteen gezegd worden dat de Vectorclass is al behoorlijk oud en er zijn latere collecties verschenen die deze in de overgrote meerderheid van de gevallen kunnen vervangen. De populaire "analoog" van Java Vector is de klasse ArrayList . Het belangrijkste verschil tussen deze klassen van elkaar is dat Vector gesynchroniseerd is, terwijl ArrayList dat niet is. We zullen het later hebben over andere verschillen tussen deze twee klassen en modernere analogen van de Vector- klasse in het gedeelte "Wat is er mis met de Vector-klasse".

Java-vectormethoden

Hier zijn Java Vector- methoden:

• void add(int index, Object element) voegt het gespecificeerde element in op de gespecificeerde positie van de vector.

• boolean add(Object o) voegt het opgegeven element toe aan het einde van de vector.

• boolean addAll(Collection c) voegt alle elementen in de opgegeven collectie toe aan het einde van de vector, in de volgorde waarin ze worden geretourneerd door de opgegeven collectie-iterator.

• boolean addAll(int index, Collection c) voegt alle elementen binnen de gespecificeerde Collection in de vector in op de gespecificeerde positie.

• void addElement(Object obj) voegt de gespecificeerde component toe aan het einde van deze vector, waardoor de grootte met één toeneemt.

• int capacity() geeft de huidige capaciteit van deze vector terug.

• void clear() verwijdert alle elementen uit deze vector.

• Object clone() retourneert een kloon van deze vector.

• boolean bevat(Object elem) test of het gespecificeerde object een component is in deze vector.

• boolean comesAll(Collection c) retourneert true als de vector alle elementen van de opgegeven Collection bevat.

• void copyInto(Object[] anArray) kopieert de componenten van deze vector naar de gespecificeerde array.

• Object elementAt(int index) retourneert de component met de opgegeven index.

• Enumeration elements() retourneert een opsomming van de componenten van deze vector.

• void sureCapacity(int minCapacity) vergroot de capaciteit van deze vector, indien nodig, om ervoor te zorgen dat deze ten minste het aantal componenten kan bevatten dat wordt gegeven door het argument minimumcapaciteit.

• boolean equals(Object o) vergelijkt het gespecificeerde object met deze vector.

• Object firstElement() retourneert de eerste component (element met index 0) van deze vector.

• Object get(int index) geeft het element terug op de gespecificeerde positie in deze vector.

• int hashCode() retourneert de hashcodewaarde voor deze vector.

• int indexOf(Object elem) zoekt naar de eerste keer dat het opgegeven argument voorkomt en test op gelijkheid met behulp van de equals-methode.

• int indexOf(Object elem, int index) zoekt naar de eerste keer dat het opgegeven argument voorkomt, beginnend bij index, en test op gelijkheid met behulp van de equals-methode.

• void insertElementAt(Object obj, int index) voegt het gespecificeerde object als een component in deze vector in op de gespecificeerde index.

• boolean isEmpty() test deze vector op ontbrekende componenten.

• Object lastElement() retourneert de laatste component van de vector.

• int lastIndexOf(Object elem) geeft de index terug van het laatste voorkomen van het gespecificeerde object in deze vector.

• int lastIndexOf(Object elem, int index) zoekt achteruit naar het opgegeven object, beginnend bij de opgegeven index, en retourneert de index ernaar.

• Object remove(int index) verwijdert het element op de gespecificeerde positie in deze vector.

• boolean remove(Object o) verwijdert het eerste voorkomen van het gespecificeerde element in deze vector. Als de vector geen element bevat, verandert deze niet.

• boolean removeAll(Collection c) verwijdert alle elementen uit de vector die in de gespecificeerde Collection zijn opgenomen.

• void removeAllElements() verwijdert alle componenten uit de vector en zet de grootte op nul.

• boolean removeElement(Object obj) verwijdert de eerste (laagste index) instantie van het argument uit deze vector.

• void removeElementAt(int index) verwijdert een element bij index.

• beschermd leegte removeRange(int fromIndex, int toIndex) verwijdert uit deze lijst alle elementen waarvan de index exclusief tussen fromIndex, inclusief en toIndex ligt.

• boolean retainAll(Collection c) behoudt alleen de elementen in de vector die in de gespecificeerde Collection zijn opgenomen.

• Object set(int index, Object element) vervangt het element op de gespecificeerde positie in deze vector door het gespecificeerde element.

• void setElementAt(Object obj, int index) stelt de component in op de gespecificeerde index van deze vector als het gegeven object.

• void setSize(int newSize) stelt de grootte van deze vector in.

• int size() geeft het aantal componenten in deze vector terug.

• List subList(int fromIndex, int toIndex) retourneert een representatie (view) van het deel van deze lijst tussen fromIndex, inclusief, en toIndex, exclusief.

• Object[] toArray() retourneert een array die alle elementen van deze vector in de juiste volgorde bevat.

• Object[] toArray(Object[] a) geeft een array terug die alle elementen van deze vector in de juiste volgorde bevat; het uitvoeringstype van de geretourneerde array is het type van de opgegeven array.

• String toString() retourneert een tekenreeksrepresentatie van deze vector met een tekenreeksrepresentatie van elk element.

• void trimToSize() trimt de capaciteit van deze vector tot de huidige grootte van de vector.

Java Vector-voorbeeld

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

   }
}

De uitvoer van dit programma is hieronder:

Wat is er mis met Vectorklasse?

Volgens de documentatie van de Java Vector- klasse wordt aanbevolen om ArrayList te gebruiken in plaats van Vector als u geen thread-safe implementatie in uw programma nodig hebt (Collection Framework effectievere deelnemer). Laten we het bovenstaande voorbeeld een beetje veranderen door de klasse ArrayList te gebruiken in plaats van Vector .

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

       }
   }

We hebben de regel becommentarieerd met vector.indexOf("Johnny", 1) , omdat een dergelijke methode niet bestaat in deze variatie in de klasse ArrayList . Om dezelfde reden is de regel vector.firstElement() becommentarieerd. In alle andere opzichten produceert het programma hetzelfde resultaat als het eerste. In zo'n voorbeeld is het natuurlijk niet duidelijk waarom ArrayList beter is dan Vector . Dit vereist meer kennis over bijvoorbeeld threads. We zetten de redenen hier op een rij. Ten eerste, hoewel de Vector- klasse gesynchroniseerd is, kan hij niet volledig thread-safe worden genoemd, hoewel dit vreemd lijkt. Feit is dat Vector elke bewerking synchroniseert, niet de hele Vectorinstantie zelf. Dit kan een probleem zijn in programma's waarbij u de volledige reeks bewerkingen moet synchroniseren in plaats van afzonderlijke bewerkingen. Stel dat een thread itereert over een vector en een andere thread structureel een instantie van de vector aan het wijzigen is, dan zal de iterator een ConcurrentModificationException genereren . Het blijkt dat twee threads tegelijkertijd met een Vector- instantie kunnen werken als ze verschillende bewerkingen uitvoeren. Ten tweede de vectorclass heeft niet de beste prestaties omdat de objecten een aanpasbare array en synchronisatie hebben. Deze combinatie betekent extra overhead voor het blokkeren van bewerkingen, ongeacht of synchronisatie vereist is of niet. Natuurlijk heeft dit invloed op de prestaties. Bovendien heeft het synchroniseren van de vector bij elke bewerking ook een negatief effect op de prestaties, aangezien we voor elke bewerking keer op keer een vergrendeling krijgen. Als de hele instantie van de klasse zou worden gesynchroniseerd, zou de vergrendeling ook één keer worden verkregen, wat veel efficiënter is. Ten derde ondersteunt Vector enkele verouderde methoden. Bijvoorbeeld elementen(). Deze methode retourneert een opsomming van de componenten van de vector. Programmeurs gebruiken meestal Iterator of ListIterator voor Enumeration, en om een ​​aantal redenen. In het bijzonder heeft Enumeration geen methode remove() gedefinieerd, wat betekent dat de lijst tijdens iteratie niet structureel kan worden gewijzigd. Ook biedt Enumeration, in tegenstelling tot ListIterator, geen bidirectionele toegang. Zoals je kunt zien, heeft Vector nogal wat problemen. Wat als u nog steeds een thread-safe implementatie van de List-interface nodig heeft? In dit geval helpt ArrayList niet, maar u kunt bijvoorbeeld de klasse CopyOnWriteArrayList gebruiken in plaats van Vector ; het is gepositioneerd als een thread-safe variant van de ArrayList. U kunt ArrayList ook synchroniseren met behulp van de Collections synchroonList() -methode.

Vector heeft echt wat problemen... waarom is het nog steeds in Java en waarom zou het moeten worden onderwezen?

De vraag rijst: waarom bestuderen we de Vector- klasse überhaupt? En waarom is het nog niet van Java verwijderd? Feit is dat Java het principe van achterwaartse compatibiliteit belijdt. Dit betekent dat alle oude code die vele jaren geleden is geschreven, zal worden begrepen door moderne versies van Java. Daarnaast zijn er nogal wat enterprise-level applicaties in de Java-omgeving die al tientallen jaren worden ondersteund. Het is heel goed mogelijk dat je in je werk met zo'n "dinosaurus" te maken krijgt, dus je moet voorbereid zijn op verrassingen, zoals code met ineffectieve legacy-klassen.