Java vektor

Valószínűleg találkoztál már Java tömbökkel, és tudod, hogy az egyik fő hátrányuk a méretállandóság. Miután létrehozott egy bizonyos méretű tömböt, azt később már nem módosíthatja. A Java nyelvben számos Java Collection keretrendszer létezik, amelyek megoldják ezt a problémát. Az egyik a Java Vector Class. Ebben a cikkben lesz szó róla.

Mi az a Vector osztály

Ahogy az előszóban írtuk, a Java Collection Framework Vector osztálya kiküszöböli a tömbök statikus méretének problémáját. A Java Vector egyfajta dinamikus tömb, amely mérete nőhet vagy csökkenhet. A Vector gyűjtemény osztály használatával elemek egy csoportját egyszerű objektumként tárolhatjuk, és különféle módszerekkel manipulálhatjuk. A Vector osztály a java.util csomagból érhető el . Így a Java-ban lévő Vector akkor használható, ha nem ismeri előre a tömb méretét, vagy ha olyan "tömbre" van szüksége, amely a program élettartama során megváltoztathatja a méreteket. Azonnal el kell mondani, hogy a Vektorosztály már meglehetősen régi, és később megjelentek olyan gyűjtemények, amelyek az esetek túlnyomó többségében helyettesíthetik. A Java Vector népszerű „analógja” az ArrayList osztály. A legfontosabb különbség ezen osztályok között az, hogy a Vector szinkronizált, míg az ArrayList nem. A két osztály közötti egyéb különbségekről és a Vector osztály modernebb analógjairól egy kicsit később, a „Mi a baj a Vector osztállyal” részben fogunk beszélni.

Java vektoros módszerek

Íme a Java vektoros módszerek:

• void add(int index, Object element) beszúrja a megadott elemet a vektor meghatározott helyére.

• logikai add(Object o) hozzáadja a megadott elemet a vektor végéhez.

• A boolean addAll(Collection c) a megadott gyűjtemény összes elemét hozzáadja a vektor végéhez, abban a sorrendben, ahogyan azokat a megadott gyűjteményiterátor visszaadja.

• A logikai addAll(int index, Collection c) a megadott gyűjtemény összes elemét beszúrja a vektorba a megadott pozícióban.

• void addElement(Object obj) hozzáadja a megadott komponenst ennek a vektornak a végéhez, eggyel növelve a méretét.

• Az int kapacitás() ennek a vektornak a jelenlegi kapacitását adja vissza.

• A void clear() eltávolítja az összes elemet ebből a vektorból.

• Az Object clone() ennek a vektornak a klónját adja vissza.

• A boolean include(Object elem) azt teszteli, hogy a megadott objektum komponens-e ebben a vektorban.

• A boolean includeAll(Collection c) értéke igaz, ha a vektor tartalmazza a megadott gyűjtemény összes elemét.

• void copyInto(Object[] anArray) átmásolja ennek a vektornak a komponenseit a megadott tömbbe.

• Az objektum elemAt(int index) a megadott indexen lévő komponenst adja vissza.

• Az Enumeration elements() ennek a vektornak a komponenseinek felsorolását adja vissza.

• void secureCapacity(int minCapacity) szükség esetén növeli ennek a vektornak a kapacitását, hogy legalább annyi komponenst tartalmazzon, amennyit a minimális kapacitás argumentum megad.

• A boolean equals(Object o) összehasonlítja a megadott objektumot ezzel a vektorral.

• Az Object firstElement() ennek a vektornak az első komponensét (a 0 indexű elemet) adja vissza.

• Az objektum get(int index) a vektorban megadott pozícióban lévő elemet adja vissza.

• Az int hashCode() ennek a vektornak a hash kód értékét adja vissza.

• int indexOf(Object elem) az adott argumentum első előfordulását keresi, az egyenlőség módszerrel tesztelve az egyenlőséget.

• int indexOf(Object elem, int index) megkeresi az adott argumentum első előfordulását, az indextől kezdve, és az egyenlőség módszerrel teszteli az egyenlőséget.

• void insertElementAt(Object obj, int index) beszúrja a megadott objektumot komponensként ebbe a vektorba a megadott indexen.

• A logikai isEmpty() teszteli ezt a vektort a hiányzó komponensek keresésére.

• A lastElement() objektum a vektor utolsó komponensét adja vissza.

• int lastIndexOf(Object elem) a megadott objektum utolsó előfordulásának indexét adja vissza ebben a vektorban.

• int lastIndexOf(Object elem, int index) visszafelé keresi a megadott objektumot, a megadott indextől kezdve, és visszaadja az indexet.

• Az objektum eltávolítása(int index) eltávolítja az elemet a vektor meghatározott helyéről.

• A boolean remove(Object o) eltávolítja a megadott elem első előfordulását ebben a vektorban. Ha a vektor nem tartalmaz elemet, akkor nem változik.

• A boolean removeAll(Collection c) eltávolítja az összes olyan elemet a vektorból, amely a megadott gyűjteményben található.

• void removeAllElements() eltávolítja az összes komponenst a vektorból, és a méretét nullára állítja.

• A boolean removeElement(Object obj) eltávolítja az argumentum első (legalacsonyabb indexű) előfordulását ebből a vektorból.

• void removeElementAt(int index) eltávolít egy elemet az indexben.

• Protected void removeRange(int fromIndex, int toIndex) eltávolítja ebből a listából az összes olyan elemet, amelynek indexe fromIndex, inclusive és toIndex között van, kizárólagosan.

• A logikai retenAll(Collection c) csak azokat az elemeket tartja meg a vektorban, amelyek a megadott gyűjteményben találhatók.

• Az objektumkészlet(int index, objektumelem) lecseréli az ebben a vektorban megadott helyen lévő elemet a megadott elemre.

• void setElementAt(Object obj, int index) ennek a vektornak a megadott indexén lévő komponenst állítja be adott objektumként.

• void setSize(int newSize) beállítja ennek a vektornak a méretét.

• Az int size() az ebben a vektorban lévő komponensek számát adja vissza.

• A List subList(int fromIndex, int toIndex) a Lista fromIndex, inclusive és toIndex közötti részének reprezentációját (nézetét) adja vissza, kizárólagosan.

• Az Object[] toArray() egy tömböt ad vissza, amely ennek a vektornak az összes elemét tartalmazza a megfelelő sorrendben.

• Az Object[] toArray(Object[] a) egy tömböt ad vissza, amely ennek a vektornak az összes elemét tartalmazza a megfelelő sorrendben; a visszaadott tömb végrehajtási típusa a megadott tömb típusa.

• A String toString() ennek a vektornak egy karakterlánc-reprezentációját adja vissza, amely minden elem karakterlánc-ábrázolását tartalmazza.

• A void trimToSize() levágja ennek a vektornak a kapacitását a vektor aktuális méretére.

Java vektoros példa

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

   }
}

A program kimenete itt található:

Mi a baj a Vector Class-szal?

A Java Vector osztály dokumentációja szerint , ha nincs szüksége szálbiztos implementációra a programban, akkor a Vector helyett az ArrayList (Collection Framework hatékonyabb résztvevő) használata javasolt. Változtassuk meg egy kicsit a fenti példán, használjuk az ArrayList osztályt Vector helyett .

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

       }
   }

A sort a vector.indexOf("Johnny", 1) paraméterrel kommentáltuk , mert az ArrayList osztályban ebben a változatban nincs ilyen metódus . Ugyanezen okból a vector.firstElement() sor megjegyzést kapott. Minden más tekintetben a program ugyanazt az eredményt adja, mint az első. Természetesen egy ilyen példában nem világos, hogy az ArrayList miért jobb, mint a Vector . Ehhez több tudás kell mondjuk szálakkal kapcsolatban. Az okokat itt soroljuk fel. Először is, bár a Vector osztály szinkronizált, nem nevezhető teljesen szálbiztosnak, bár ez furcsának tűnik. A helyzet az, hogy a Vector minden műveletet szinkronizál, nem a teljes vektortmagát a példányt. Ez problémát jelenthet azokban a programokban, ahol az egyes műveletek helyett a teljes műveletkészletet kell szinkronizálni. Tegyük fel, hogy ha az egyik szál egy vektoron iterál, és egy másik szál szerkezetileg módosítja a vektor egy példányát, az iterátor egy ConcurrentModificationExceptiont dob . Kiderült, hogy két szál egyszerre tud működni egy Vector- példánnyal, ha különböző műveleteket hajt végre. Másodszor, a vektorosztály nem a legjobb teljesítményt nyújtja, mert az objektumai átméretezhető tömbbel és szinkronizálással rendelkeznek. Ez a kombináció további többletköltséget jelent a blokkolási műveletekhez, függetlenül attól, hogy szükséges-e a szinkronizálás vagy sem. Persze ez befolyásolja a teljesítményt. Ráadásul az egyes műveleteknél a vektorok szinkronizálása is negatív hatással van a teljesítményre, hiszen minden művelethez újra és újra kapunk egy zárolást. Ha az osztály teljes példánya szinkronizálva lenne, akkor a zárolás is egyszer megtörténik, ami sokkal hatékonyabb. Harmadszor, a Vector támogat néhány örökölt módszert. Például elements(). Ez a metódus a vektor összetevőinek felsorolását adja vissza. A programozók leggyakrabban az Iterátort vagy a ListIteratort használják a felsoroláshoz, és ennek számos oka van. Különösen az Enumeration nem rendelkezik eltávolítási() metódussal, ami azt jelenti, hogy a lista szerkezetileg nem módosítható az iteráció során. Ezenkívül a ListIteratorral ellentétben az Enumeration nem kínál kétirányú hozzáférést. Mint látható, a Vector- nak jó néhány problémája van. Mi van, ha továbbra is szüksége van a List felület szálbiztos megvalósítására? Ebben az esetben az ArrayList nem segít, de használhatod például a CopyOnWriteArrayList osztályt a Vector helyett ; az ArrayList szálbiztos változataként van elhelyezve. Az ArrayList a Collections synchronizedList() metódussal is szinkronizálható .

A vektornak tényleg vannak problémái... miért van még mindig Java-ban és miért kell tanítani?

Felmerül a kérdés: miért tanuljuk egyáltalán a Vector osztályt? És miért nem távolították el még a Java-ról? A tény az, hogy a Java a visszafelé kompatibilitás elvét vallja. Ez azt jelenti, hogy a Java modern verziói minden régi, sok évvel ezelőtt írt kódot megértenek. Emellett jó néhány vállalati szintű alkalmazás létezik a Java környezetben, amelyeket évtizedek óta támogatnak. Nagyon valószínű, hogy egy ilyen „dinoszaurusszal” kell megküzdenie a munkája során, ezért fel kell készülnie olyan meglepetésekre, mint például a nem hatékony örökölt osztályok kódja.