Java vektor

Förmodligen har du redan stött på arrayer i Java, och du vet att en av deras största nackdelar är storlekskonstans. När du väl har skapat en array av en viss storlek kan du inte ändra det senare. Det finns flera Java Collection-ramverksklasser i Java-språket som löser detta problem. En av dem är Java Vector Class. Det kommer att diskuteras i den här artikeln.

Vad är Vector Class

Som vi skrev i förordet eliminerar Vector- klassen från Java Collection Framework problemet med den statiska storleken på arrayer. Java Vector är en slags dynamisk array och kan växa eller krympa i storlek. Med hjälp av klassen Vector collection kan vi lagra en grupp av element som enkla objekt och manipulera dem genom de olika metoderna. Vector-klassen är tillgänglig från paketet java.util . Således kan Vector i Java användas om du inte vet storleken på arrayen i förväg, eller om du behöver en "array" som kan ändra dimensioner under programmets livstid. Det måste sägas direkt att Vectorklass är redan ganska gammal, och senare uppkom samlingar som kan ersätta den i de allra flesta fall. Den populära "analogen" av Java Vector är klassen ArrayList . Den viktigaste skillnaden mellan dessa klasser från varandra är att Vector är synkroniserad, medan ArrayList inte är det. Vi kommer att prata om andra skillnader mellan dessa två klasser och mer moderna analoger av Vector -klassen lite senare i avsnittet "Vad är det för fel med Vector-klassen".

Java vektormetoder

Här är Java Vector Methods:

• void add(int index, Objektelement) infogar det angivna elementet vid den angivna positionen för vektorn.

• boolean add(Object o) lägger till det angivna elementet i slutet av vektorn.

• boolean addAll(Collection c) lägger till alla element i den angivna samlingen till slutet av vektorn, i den ordning som de returneras av den angivna samlingsiteratorn.

• boolean addAll(int index, Collection c) infogar alla element inom den angivna samlingen i vektorn på den angivna positionen.

• void addElement(Object obj) lägger till den angivna komponenten i slutet av denna vektor och ökar dess storlek med en.

• int kapacitet() returnerar den aktuella kapaciteten för denna vektor.

• void clear() tar bort alla element från denna vektor.

• Object clone() returnerar en klon av denna vektor.

• boolean contains(Object elem) testar om det angivna objektet är en komponent i denna vektor.

• boolean containsAll(Collection c) returnerar sant om vektorn innehåller alla element i den angivna samlingen.

• void copyInto(Object[] anArray) kopierar komponenterna i denna vektor till den angivna arrayen.

• Object elementAt(int index) returnerar komponenten vid det angivna indexet.

• Enumeration elements() returnerar en uppräkning av komponenterna i denna vektor.

• void sureCapacity(int minCapacity) ökar kapaciteten för denna vektor, om nödvändigt, för att säkerställa att den kan innehålla åtminstone det antal komponenter som ges av argumentet för minimumkapacitet.

• boolean equals(Object o) jämför det angivna objektet med denna vektor.

• Objekt firstElement() returnerar den första komponenten (element vid index 0) i denna vektor.

• Objekt get(int index) returnerar elementet vid den angivna positionen i denna vektor.

• int hashCode() returnerar hashkodvärdet för denna vektor.

• int indexOf(Object elem) söker efter den första förekomsten av det givna argumentet och testar för likhet med metoden equals.

• int indexOf(Objekt elem, int index) söker efter den första förekomsten av det givna argumentet, med början vid index, och testar för likhet med metoden equals.

• void insertElementAt(Object obj, int index) infogar det angivna objektet som en komponent i denna vektor vid det angivna indexet.

• boolean isEmpty() testar denna vektor för saknade komponenter.

• Objekt lastElement() returnerar den sista komponenten i vektorn.

• int lastIndexOf(Objekt elem) returnerar indexet för den senaste förekomsten av det angivna objektet i denna vektor.

• int lastIndexOf(Objekt elem, int index) söker bakåt efter det angivna objektet, med början vid det angivna indexet, och returnerar indexet till det.

• Object remove(int index) tar bort elementet på den angivna positionen i denna vektor.

• boolean remove(Object o) tar bort den första förekomsten av det angivna elementet i denna vektor. Om vektorn inte innehåller ett element ändras den inte.

• boolean removeAll(Collection c) tar bort alla element från vektorn som finns i den angivna samlingen.

• void removeAllElements() tar bort alla komponenter från vektorn och ställer in dess storlek till noll.

• boolean removeElement(Object obj) tar bort den första (lägsta index) förekomsten av argumentet från denna vektor.

• void removeElementAt(int index) tar bort ett element vid index.

• protected void removeRange(int fromIndex, int toIndex) tar bort från denna lista alla element vars index är mellan fromIndex, inklusive, och toIndex, exklusivt.

• boolean retainAll(Collection c) behåller endast de element i vektorn som finns i den angivna samlingen.

• Objektuppsättning (int index, Objektelement) ersätter elementet på den angivna positionen i denna vektor med det angivna elementet.

• void setElementAt(Object obj, int index) ställer in komponenten vid det specificerade indexet för denna vektor som det givna objektet.

• void setSize(int newSize) ställer in storleken på denna vektor.

• int size() returnerar antalet komponenter i denna vektor.

• List subList(int fromIndex, int toIndex) returnerar en representation (vy) av den del av denna lista mellan fromIndex, inklusive, och toIndex, exklusivt.

• Object[] toArray() returnerar en array som innehåller alla element i denna vektor i rätt ordning.

• Objekt[] tillArray(Objekt[] a) returnerar en array som innehåller alla element i denna vektor i rätt ordning; exekveringstypen för den returnerade arrayen är typen av den angivna arrayen.

• String toString() returnerar en strängrepresentation av denna vektor som innehåller en strängrepresentation av varje element.

• void trimToSize() trimmar kapaciteten för denna vektor till vektorns nuvarande storlek.

Java vektor exempel

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 av detta program är här nedan:

Vad är det för fel på Vector Class?

Enligt dokumentationen för Java Vector -klassen, om du inte behöver en trådsäker implementering i ditt program, rekommenderas det att använda ArrayList istället för Vector (Collection Framework effektivare deltagare). Låt oss ändra exemplet ovan lite genom att använda klassen ArrayList istället för 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 kommenterade raden med vector.indexOf("Johnny", 1) , eftersom det inte finns någon sådan metod i denna variant i klassen ArrayList . Av samma anledning kommenterades raden vector.firstElement() bort. I alla andra avseenden ger programmet samma resultat som det första. Naturligtvis, i ett sådant exempel är det inte klart varför ArrayList är bättre än Vector . Detta kräver mer kunskap om till exempel trådar. Vi listar orsakerna här. För det första, även om Vector -klassen är synkroniserad, kan den inte kallas helt trådsäker, även om detta verkar konstigt. Faktum är att Vector synkroniserar varje operation, inte hela Vectorsjälva instansen. Detta kan vara ett problem i program där du behöver synkronisera hela uppsättningen av operationer snarare än enskilda operationer. Säg, om en tråd itererar över en vektor och en annan tråd strukturellt modifierar en instans av vektorn, kommer iteratorn att kasta ett ConcurrentModificationException . Det visar sig att två trådar kan fungera med en Vector- instans samtidigt om de utför olika operationer. För det andra, vektornclass har inte den bästa prestandan eftersom dess objekt har en storleksändringsbar array och synkronisering. Denna kombination innebär ytterligare overhead för blockeringsoperationer, oavsett om synkronisering krävs eller inte. Visst, detta påverkar prestandan. Dessutom har synkronisering av vektorn på varje operation också en negativ effekt på prestandan, eftersom vi kommer att få ett lås om och om igen för varje operation. Om hela instansen av klassen synkroniserades, skulle låset också förvärvas en gång, vilket är mycket mer effektivt. För det tredje stöder Vector vissa äldre metoder. Till exempel element(). Denna metod returnerar en uppräkning av komponenterna i vektorn. Programmerare använder oftast Iterator eller ListIterator till Enumeration, och av ett antal anledningar. I synnerhet har Enumeration inte en remove() -metod definierad, vilket innebär att listan inte kan modifieras strukturellt under iteration. Till skillnad från ListIterator erbjuder Enumeration inte dubbelriktad åtkomst. Som du kan se har Vector en hel del problem. Vad händer om du fortfarande behöver en trådsäker implementering av List-gränssnittet? I det här fallet hjälper ArrayList inte, men du kan till exempel använda klassen CopyOnWriteArrayList istället för Vector ; den är placerad som en trådsäker variant av ArrayList. Du kan också synkronisera ArrayList med metoden Collections synchronizedList() .

Vector har verkligen några problem... varför är det fortfarande i Java och varför ska det läras ut?

Frågan uppstår: varför studerar vi vektorklassen överhuvudtaget? Och varför har den inte tagits bort från Java än? Faktum är att Java bekänner sig till principen om bakåtkompatibilitet. Det betyder att all gammal kod som skrevs för många år sedan kommer att förstås av moderna versioner av Java. Dessutom finns det en hel del applikationer på företagsnivå i Java-miljön som har stötts i decennier. Det är mycket möjligt att du kommer att behöva hantera en sådan "dinosaurie" i ditt arbete, så du måste vara beredd på överraskningar, till exempel kod med ineffektiva äldre klasser.