Java vektor

Sandsynligvis har du allerede stødt på arrays i Java, og du ved, at en af ​​deres største ulemper er størrelseskonstans. Når du først har oprettet et array af en bestemt størrelse, kan du ikke ændre det senere. Der er flere Java Collection-rammeklasser i Java-sproget, der løser dette problem. En af dem er Java Vector Class. Det vil blive diskuteret i denne artikel.

Hvad er Vector Class

Som vi skrev i forordet, eliminerer Vector -klassen fra Java Collection Framework problemet med den statiske størrelse af arrays. Java Vector er en slags dynamisk array og kan vokse eller krympe i størrelse. Ved hjælp af Vector collection-klassen kan vi gemme en gruppe elementer som simple objekter og manipulere dem gennem de forskellige metoder. Vector-klassen er tilgængelig fra pakken java.util . Således kan Vector i Java bruges, hvis du ikke kender størrelsen på arrayet på forhånd, eller hvis du har brug for et "array", der kan ændre dimensioner i løbet af programmets levetid. Det skal siges med det samme, at Vectorklasse er allerede ret gammel, og senere dukkede der samlinger op, der kan erstatte den i langt de fleste tilfælde. Den populære "analog" af Java Vector er ArrayList- klassen. Den vigtigste forskel mellem disse klasser fra hinanden er, at Vector er synkroniseret, mens ArrayList ikke er det. Vi vil tale om andre forskelle mellem disse to klasser og mere moderne analoger af Vector- klassen lidt senere i afsnittet "Hvad er der galt med Vector-klassen".

Java vektor metoder

Her er Java Vector Methods:

• void add(int index, Object element) indsætter det specificerede element på den angivne position af vektoren.

• boolean add(Object o) tilføjer det angivne element til slutningen af ​​vektoren.

• boolean addAll(Collection c) tilføjer alle elementerne i den angivne samling til slutningen af ​​vektoren i den rækkefølge, som de returneres af den specificerede samling iterator.

• boolean addAll(int index, Collection c) indsætter alle elementer i den specificerede samling i vektoren på den angivne position.

• void addElement(Object obj) tilføjer den specificerede komponent til slutningen af ​​denne vektor og øger dens størrelse med én.

• int kapacitet() returnerer den aktuelle kapacitet af denne vektor.

• void clear() fjerner alle elementer fra denne vektor.

• Object clone() returnerer en klon af denne vektor.

• boolean contains(Object elem) tester, om det angivne objekt er en komponent i denne vektor.

• boolean containsAll(Collection c) returnerer sand, hvis vektoren indeholder alle elementer i den angivne samling.

• void copyInto(Object[] anArray) kopierer komponenterne i denne vektor til det angivne array.

• ObjektelementAt(int indeks) returnerer komponenten ved det angivne indeks.

• Enumeration elements() returnerer en opregning af komponenterne i denne vektor.

• void sureCapacity(int minCapacity) øger kapaciteten af ​​denne vektor, hvis det er nødvendigt, for at sikre, at den kan indeholde mindst det antal komponenter, der er givet af minimumskapacitetsargumentet.

• boolean equals(Object o) sammenligner det angivne objekt med denne vektor.

• Objekt firstElement() returnerer den første komponent (element ved indeks 0) af denne vektor.

• Objekt get(int indeks) returnerer elementet på den angivne position i denne vektor.

• int hashCode() returnerer hashkodeværdien for denne vektor.

• int indexOf(Object elem) søger efter den første forekomst af det givne argument og tester for lighed ved hjælp af equals-metoden.

• int indexOf(Objekt elem, int index) søger efter den første forekomst af det givne argument, startende ved indeks, og tester for lighed ved hjælp af equals-metoden.

• void insertElementAt(Object obj, int index) indsætter det angivne objekt som en komponent i denne vektor ved det angivne indeks.

• boolean isEmpty() tester denne vektor for manglende komponenter.

• Objekt lastElement() returnerer den sidste komponent i vektoren.

• int lastIndexOf(Object elem) returnerer indekset for den sidste forekomst af det angivne objekt i denne vektor.

• int lastIndexOf(Objekt elem, int indeks) søger baglæns efter det angivne objekt, startende ved det angivne indeks, og returnerer indekset til det.

• Object remove(int index) fjerner elementet på den angivne position i denne vektor.

• boolean remove(Object o) fjerner den første forekomst af det angivne element i denne vektor. Hvis vektoren ikke indeholder et element, ændres den ikke.

• boolean removeAll(Collection c) fjerner alle elementer fra vektoren, der er indeholdt i den angivne samling.

• void removeAllElements() fjerner alle komponenter fra vektoren og sætter dens størrelse til nul.

• boolean removeElement(Object obj) fjerner den første (laveste indeks) forekomst af argumentet fra denne vektor.

• void removeElementAt(int index) fjerner et element ved index.

• beskyttet void removeRange(int fromIndex, int toIndex) fjerner udelukkende fra denne liste alle elementer, hvis indeks er mellem fromIndex, inklusive og toIndex.

• boolean retainAll(Collection c) beholder kun de elementer i vektoren, der er indeholdt i den specificerede samling.

• Objektsæt(int index, Objektelement) erstatter elementet på den angivne position i denne vektor med det angivne element.

• void setElementAt(Object obj, int index) sætter komponenten ved det specificerede indeks for denne vektor som det givne objekt.

• void setSize(int newSize) indstiller størrelsen på denne vektor.

• int size() returnerer antallet af komponenter i denne vektor.

• List subList(int fromIndex, int toIndex) returnerer en repræsentation (visning) af den del af denne liste, der udelukkende er mellem fromIndex, inklusive og toIndex.

• Objekt[] toArray() returnerer et array, der indeholder alle elementerne i denne vektor i den korrekte rækkefølge.

• Objekt[] tilArray(Objekt[] a) returnerer et array, der indeholder alle elementerne i denne vektor i den rigtige rækkefølge; udførelsestypen for det returnerede array er typen af ​​det angivne array.

• String toString() returnerer en strengrepræsentation af denne vektor, der indeholder en strengrepræsentation af hvert element.

• void trimToSize() trimmer kapaciteten af ​​denne vektor til vektorens aktuelle størrelse.

Java vektor eksempel

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

   }
}

Resultatet af dette program er her nedenfor:

Hvad er der galt med Vector Class?

Ifølge dokumentationen af ​​Java Vector -klassen, hvis du ikke har brug for en trådsikker implementering i dit program, anbefales det at bruge ArrayList i stedet for Vector (Collection Framework mere effektiv deltager). Lad os ændre eksemplet ovenfor lidt ved at bruge ArrayList- klassen i stedet for 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());

       }
   }

Vi kommenterede linjen ud med vector.indexOf("Johnny", 1) , fordi der ikke er en sådan metode i denne variant i ArrayList- klassen. Af samme grund blev linjen vector.firstElement() kommenteret ud. I alle andre henseender giver programmet samme resultat som det første. I et sådant eksempel er det selvfølgelig ikke klart, hvorfor ArrayList er bedre end Vector . Dette kræver mere viden om f.eks. tråde. Vi lister årsagerne her. For det første, selvom Vector- klassen er synkroniseret, kan den ikke kaldes helt trådsikker, selvom det virker mærkeligt. Faktum er, at Vector synkroniserer hver operation, ikke hele Vectorselve instansen. Dette kan være et problem i programmer, hvor du skal synkronisere hele sættet af operationer i stedet for individuelle operationer. Lad os sige, hvis en tråd itererer over en vektor, og en anden tråd strukturelt modificerer en forekomst af vektoren, vil iteratoren kaste en ConcurrentModificationException . Det viser sig, at to tråde kan arbejde med en Vector- instans på samme tid, hvis de udfører forskellige operationer. For det andet vektorenklasse har ikke den bedste ydeevne, fordi dens objekter har et array, der kan ændres størrelse, og synkronisering. Denne kombination betyder yderligere overhead til blokeringsoperationer, uanset om synkronisering er påkrævet eller ej. Selvfølgelig påvirker dette ydeevnen. Derudover har synkronisering af vektoren på hver operation også en negativ effekt på ydeevnen, da vi får en lås igen og igen for hver operation. Hvis hele forekomsten af ​​klassen var synkroniseret, ville låsen også blive erhvervet én gang, hvilket er meget mere effektivt. For det tredje understøtter Vector nogle ældre metoder. For eksempel elementer(). Denne metode returnerer en opregning af vektorens komponenter. Programmører bruger oftest Iterator eller ListIterator til Enumeration, og det af en række årsager. Især har Enumeration ikke en remove()- metode defineret, hvilket betyder, at listen ikke kan ændres strukturelt under iteration. I modsætning til ListIterator tilbyder Enumeration heller ikke tovejsadgang. Som du kan se, har Vector en del problemer. Hvad hvis du stadig har brug for en trådsikker implementering af List-grænsefladen? I dette tilfælde hjælper ArrayList ikke, men du kan f.eks. bruge CopyOnWriteArrayList -klassen i stedet for Vector ; den er placeret som en trådsikker variant af ArrayList. Du kan også synkronisere ArrayList ved hjælp af Collections synchronizedList() -metoden.

Vector har virkelig nogle problemer... hvorfor er det stadig i Java, og hvorfor skal det undervises?

Spørgsmålet opstår: hvorfor studerer vi overhovedet Vector- klassen? Og hvorfor er det ikke blevet fjernet fra Java endnu? Faktum er, at Java bekender sig til princippet om bagudkompatibilitet. Det betyder, at al gammel kode skrevet for mange år siden vil blive forstået af moderne versioner af Java. Derudover er der en del applikationer på virksomhedsniveau i Java-miljøet, som har været understøttet i årtier. Det er meget muligt, at du bliver nødt til at håndtere sådan en "dinosaur" i dit arbejde, så du skal være forberedt på overraskelser, såsom kode med ineffektive arveklasser.