Ez a bemutató elmagyaráz mindent a Vektor adatszerkezet Java példákkal. Megtanulja, hogy hozzon létre, Kezdeti, Rendezés & amp; Használja a Java Vektor a programokban:
A vektor egy dinamikus tömbként definiálható, amely önmagától nő vagy zsugorodik, azaz a vektor nő, ha több elemet adunk hozzá, és zsugorodik, ha elemeket veszünk ki belőle.
Ez a viselkedés eltér a tömbökétől, amelyek statikusak. De a tömbökhöz hasonlóan a vektorelemek is elérhetők egész számú indexek segítségével.
A vektor egy másik dinamikus tömb adatszerkezethez hasonlónak tekinthető, ArrayList, kivéve az alábbi két különbséget:
- A vektor szinkronizált, azaz a vektor összes metódusa "szinkronizált" jelöléssel van ellátva, és így ha egyszer egy metódust meghívunk, ugyanazt a metódust nem lehet meghívni, amíg az előző hívás véget nem ér.
- A vektor osztály számos olyan metódussal rendelkezik, amelyek nem a gyűjtemények keretrendszerének részei, hanem annak örökölt metódusai.
Java Vector osztály
A Vector osztály a " java.util " csomagot, és megvalósítja a List interfészt. A Vector objektumok tömbje vagy objektumok vektora.
A Vector osztály osztálydeklarációja az alábbiakban látható:
public class Vector extends Object implements List, Cloneable, Serializable
Mint fentebb látható, egy Vector osztály kiterjeszti a " java.lang.object " és a List, Cloneable és Serializable interfészeket valósítja meg.
Hogyan hozzunk létre egy vektort Java-ban?
Vektor objektumot a következő Vector konstruktor metódusok bármelyikével létrehozhat.
Konstruktor Prototípus | Leírás |
---|---|
vector() | Ez a Vector osztály alapértelmezett konstruktora, amely egy üres, 10-es méretű vektort hoz létre. |
vector(int initialCapacity) | Ez a túlterhelt konstruktor egy üres Vector objektumot hoz létre a capacity = initialCapacity értékkel. |
vector(int initialCapacity, int capacityIncrement) | Ez a konstruktormódszer egy üres Vector objektumot hoz létre a megadott initialCapacity és capacityIncrement értékekkel. |
Vektor( Gyűjtemény c) | Egy Vector objektum jön létre a megadott c gyűjtemény kezdeti elemeivel. |
Nézzük meg az egyes konstruktorokat a Vector objektumok inicializálásához.
Vektor inicializálása
(i) Vektor()
Ez a Vector osztály alapértelmezett konstruktora. Amikor ezt a konstruktort hívja meg, egy 10-es alapértelmezett méretű Vector objektum jön létre.
A módszer általános szintaxisa a következő:
Vector object = new Vector();
Például,
Vektor vec1 = új Vektor ();
A fenti utasítás létrehoz egy új, 10 méretű 'vec1' vektort.
(ii) Vektor(int initialCapacity)
A Vector osztály túlterhelt konstruktora elfogadja az 'initialCapacity' argumentumot. Ez a konstruktor létrehoz egy Vector objektumot a megadott kapacitással.
A módszer általános szintaxisa a következő:
Vector object = új Vector (initialCapacity);
Például,
Vektor vec1 = új Vektor (10);
A fenti programozási utasítás létrehoz egy Vector objektumot 'vec1' 10-es kapacitással, azaz ez a Vector legfeljebb 10 elemet tud tárolni.
(iii) Vektor(int initialCapacity, int capacityIncrement)
Ez a Vector osztály egy újabb túlterhelt konstruktora, amely egy Vector objektumot hoz létre a megadott kezdeti kapacitással és a kapacitás növekményével.
A módszer általános szintaxisa a következő:
Vector object = új Vector (initialCapacity, capacityIncrement);
Például,
Vektor vec1 = új Vektor(5,10);
A fenti utasításban a Vektor kezdeti kapacitása 5, a növekmény pedig 10. Ez azt jelenti, hogy amikor a 6. elemet beillesztjük a vektorba, a vektor kapacitása 15-re (5 + 10) növekszik. Hasonlóképpen, amikor a 16. elemet beillesztjük, a Vektor kapacitása 25-re (15 + 10) növekszik.
(iv) Vektor(Gyűjtemény c)
A Vector osztály utolsó túlterhelt konstruktora egy előre definiált gyűjteményt vesz fel argumentumként, és létrehoz egy Vectort, amelynek elemei a gyűjtemény összes eleme.
Az általános szintaxis a következő:
Vector object = new Vector (Collection c);
Például,
Vector vec1 = new Vector(aList); ahol aList = {1,2,3,4,5};
A fenti utasítás létrehoz egy 'vec1' vektort, amelynek kezdeti elemei {1,2,3,4, 5}.
Ha mindezeket a leírásokat szem előtt tartjuk, akkor egy Vector programot fogunk végrehajtani, hogy jobban megértsük ezeket a konstruktorokat.
Vektor módszerek Java-ban
Az alábbiakban a Vector osztály által támogatott metódusokat ismertetjük a Java-ban.
Módszer neve | Prototípus | Leírás |
---|---|---|
add | Boolean add(E e) | Hozzáadja az adott elemet a vektor végéhez. |
Void add(int index, E element) | Elem hozzáadása a vektorhoz a megadott indexnél. | |
addAll | Boolean addAll(Collection c) | A megadott gyűjtemény összes elemét hozzáadja a vektor végéhez. |
Boolean addAll(int index, Collection c) | Hozzáadja a megadott gyűjtemény összes elemét a megadott indexnél. | |
addElement | void addElement(E obj) | Hozzáadja a megadott elemet a vektor végéhez a vektor méretének növelésével. |
Kapacitás | Int kapacitás() | Visszaadja a vektor aktuális kapacitását. |
Tiszta | Void clear() | Kitisztítja a vektor elemeit. |
Clone | Object clone() | Klónozza a vektort. |
Tartalmazza a címet. | Boolean contains(Object o) | Ellenőrzi, hogy a vektor tartalmazza-e a megadott elemet. |
containsAll | Boolean containsAll(Collection c) | Ellenőrzi, hogy a vektor tartalmazza-e az adott gyűjteményben lévő összes elemet. |
copyInto | Void copyInto(Object[] anArray) | A vektor elemeit a megadott tömbbe másolja. |
ElementAt | E ElementAt(int index) | Visszaadja a megadott indexen lévő vektorelemet. |
Elemek | Enumerationelements() | Visszaadja a vektor felsorolt komponenseit. |
ensureCapacity | Void ensureCapacity(int minCapacity) | Növeli a vektor kapacitását a megadott minimális kapacitás eléréséhez. |
Módszer neve | Prototípus | Leírás |
---|---|---|
Egyenlő | Boolean equals(Object o) | Összehasonlítja az aktuális vektort a megadott vektorral, hogy ellenőrizze, egyenlőek-e. |
firstElement | E firstElement() | Visszaadja a vektor első elemét a 0 indexen. |
Szerezd meg a címet. | E get(int index) | Visszaadja a megadott indexen lévő vektor elemét. |
hashCode | int hashCode() | Visszaadja a Vektor hash kódjának értékét. |
indexOf | int indexOf(Object o) | megtalálja az adott elem első előfordulásának indexét a vektorban; -1, ha az elem nincs a vektorban. |
int indexOf(Object o, int index) | A vektorban a megadott indexből előrefelé haladva keresi a megadott elemet;visszaadja az indexet, ha az elemet megtalálta, különben -1, ha az elemet nem találja. | |
insertElementAt | Void insertElementAt(E obj, int index) | Az adott objektumot a megadott indexen beilleszti a vektorba. |
isEmpty | Boolean isEmpty() | Ellenőrzi, hogy a vektor üres-e. |
Iterátor | Iteratoriterator() | Visszaad egy iterátort, amely a vektor elemein való áthaladásra szolgál. |
lastElement | E lastElement() | Visszaadja a vektor utolsó elemét. |
lastIndexOf | Int lastIndexOf(Object o) | Megkeresi a vektorban az adott elem utolsó előfordulását, és visszaadja az indexet, vagy -1-et ad vissza, ha az elemet nem találja. |
Int lastIndexOf(Object o, int index) | Az adott elem utolsó előfordulásának keresése a megadott indexből visszafelé. Visszaadja az indexet, ha az elemet megtalálta, különben -1-et ad vissza. | |
listIterator | ListIteratorlistIterator() | Visszaad egy lista iterátort a vektor elemei felett. |
ListIteratorlistIterator(int index) | Visszaad egy lista iterátort a vektor elemei felett a megadott indexszel kezdődően. |
Módszer neve | Prototípus | Leírás |
---|---|---|
Távolítsa el a | E remove(int index) | Törli az adott indexen lévő elemet a vektorból. |
Boolean remove(Object o) | Törli a megadott elem első előfordulását a vektorból. Ha az elem nincs jelen, semmi sem történik a vektorral. | |
removeAll | Boolean removeAll(Collection c) | Törli a vektor összes olyan elemét, amely a megadott gyűjteményben található. |
void removeAll Elements() | Törli az összes vektorelemet, így a vektor mérete nullára csökken. | |
removeElement | Boolean removeElement(Object obj) | Eltávolítja az adott elem első előfordulását a vektorból. |
void removeElementAt(int index) | Törli a megadott indexen lévő elemet. | |
removeRange | protected void removeRange(int fromIndex, int toIndex) | Törli az összes elemet a vektorból a megadott tartományban fromIndex-től (beleértve), totoIndex-ig (kizárólag). |
retainAll | Boolean retainAll(Collection c) | A 'removeAll' módszerrel ellentétben a retainAll módszer megtartja a Vektor azon elemeit, amelyek megegyeznek a megadott Collection elemeivel. |
set | E set(int index, E element) | A megadott indexen lévő értéket a megadott új elemmel állítja be. |
Void set ElementAt(E obj, int index) | Az adott elemek beállítása az adott indexen. | |
setSize | Void setSize(int newSize) | Beállítja a vektor adott méretét. |
Méret | int size() | Visszaadja a vektor elemeinek számát vagy a vektor hosszát. |
subList | ListsubList(intfromIndex, inttoIndex) | Visszaadja a vektor egy nézetét vagy allistáját fromIndex-től toIndex-ig terjedő tartományban. |
toArray | Object[] toArray() | A megadott vektort egy olyan tömbtá alakítja, amely az összes vektorelemet tartalmazza a megadott sorrendben. |
T[] toArray(T[] a) | Visszaad egy megadott típusú tömböt, amely tartalmazza az összes vektorelemet. | |
toString | String toString() | Visszaadja a vektor karakterláncos ábrázolását. |
trimToSize | void trimToSize() | A vektort az aktuális mérethez igazítja. |
Vektoros megvalósítás
A következő Java program a fent leírt összes konstruktor metódus használatát mutatja be.
import java.util.*; public class Main{ public static void main(String[] args) { //Vektorok létrehozása v1, v2,v3 és v4 Vector v1 = new Vector(); //a vektor alapértelmezett konstruktorral Vector v2 = new Vector(20); // egy adott méretű vektor //inicializáljuk a v2 vektort értékekkel v2.add(10); v2.add(20); v2.add(30); Vector v3 = new Vector(30, 10); // egy adott méretű és inkrementált vektor // létrehozzuk a v4 vektort a következőveladott gyűjtemény List aList = new ArrayList(); aList.add("one"); aList.add("two"); Vector v4 = new Vector(aList); //nyomtatjuk az egyes vektorok tartalmát System.out.println("Vector v1 Contents:" + v1); System.out.println("Vector v2 Contents:" + v2); System.out.println("Vector v3 Contents:" + v3); System.out.println("Vector v4 Contents:" + v4); } }
Kimenet:
A fenti programban négy vektor van. Az első v1-et egy alapértelmezett konstruktorral hozzuk létre. A második v2 vektort 20-as kezdeti kapacitással hozzuk létre, majd néhány elemet adunk hozzá v2-hez. A harmadik vektort 30-as kezdeti kapacitással és 10-es inkrementációval hozzuk létre.
Ezután létrehozunk egy ArrayList-et, és létrehozunk egy negyedik v4-es Vektort, amelynek argumentuma az ArrayList. Végül megjelenítjük az egyes Vektorok tartalmát.
Figyeljük meg a negyedik vektor v4 tartalmát. Mivel argumentumként ArrayList-et adtunk meg, az ArrayList tartalma lesz a v4 tartalma.
Teljes vektor példa
Most pedig valósítsunk meg egy újabb programot, amely bemutatja a vektorok létrehozását, elemeinek hozzáadását és tartalmának megjelenítését.
import java.util.*; public class Main { public static void main(String args[]) { //Elkészítünk egy üres Vektort páros számokból Vector evenVector= new Vector (); //Elemek hozzáadása a vektorhoz evenVector.add(2); evenVector.add(4); evenVector.add(6); evenVector.add(8); evenVector.add(10); evenVector.add(12); evenVector.add(14); evenVector.add(16); //Display the vector System.out.println("Vector").evenVector tartalma: " +evenVector); //eltávolítjuk a 4-es elem első előfordulását a remove módszerrel System.out.println("\nA 4-es elem első előfordulása eltávolítva: "+evenVector.remove((Integer)4))); //Display the vector System.out.println("\nVector tartalma az eltávolítás után: " +evenVector); //Remove the element at index 4 & display the vector System.out.println("\nRemove element at index 4:" +evenVector.remove(4)); System.out.println("\nVektor tartalma eltávolítás után: " +evenVector); //a vektor hash-kódja System.out.println("\nVektor hash-kódja ="+evenVector.hashCode()); //az 1-es indexű elem kinyerése System.out.println("\nElement az 1-es indexű elem ="+evenVector.get(1)); } }
Kimenet:
Vegyünk egy másik vektoros példát. Ebben a programban a következő lesz string vektor használata Ezt a vektort elemek hozzáadásával manipuláljuk, majd kinyomtatjuk a méretét és a kapacitását.
import java.util.*; public class Main { public static void main(String args[]) { // létrehozunk egy vektort kezdeti kapacitással = 2 Vector fruits_vec = new Vector(2); //elemek hozzáadása a vektorhoz fruits_vec.addElement("Grapes"); fruits_vec.addElement("Melon"); fruits_vec.addElement("Kiwi"); fruits_vec.addElement("Apple"); //kiírjuk a vektor jelenlegi méretét és kapacitását System.out.println("Vector Size:"+fruits_vec.size()); System.out.println("Default Vector capacity increment: "+fruits_vec.capacity()); //add more elements to the vector fruits_vec.addElement("Orange"); fruits_vec.addElement("Mango"); fruits_vec.addElement("Fig"); //print current size and capacity again System.out.println("Vector Size after addition: "+fruits_vec.size()); System.out.println("Vector Capacity after increment:"+fruits_vec.capacity()); //vektorelemek nyomtatása Enumeráció fruits_enum = fruits_vec.elements(); System.out.println("\nVektor elemek:"); while(fruits_enum.hasMoreElements()) System.out.print(fruits_enum.nextElement() + " "); } }
Kimenet:
A vektor rendezése
Egy vektort egy adott sorrend szerint is rendezhetünk. Egy vektor rendezéséhez a Java Collections Framework Collections.sort () metódusát kell használnunk.
A következő példa a vektoros rendezést mutatja be.
import java.util.*; public class Main { public static void main(String arg[]) { //Elkészítünk egy üres vektort Vector oddVector = new Vector(); //Elemek hozzáadása a vektorhoz oddVector.add(1); oddVector.add(11); oddVector.add(7); oddVector.add(3); oddVector.add(5); //kiírjuk a vektor elemeit System.out.println("Vektor elemei: "+oddVector); //vektor rendezése a Collections.sort módszerrel.Collections.sort(oddVector); //nyomtatjuk a rendezett vektort System.out.println("Vektorelemek a rendezés után: "+oddVector); } } }
Kimenet:
A fenti program létrehoz egy Vektort páratlan számokból. Ezután a Collections.sort() metódus segítségével a Vektort rendezi.
2D (kétdimenziós) vektor
A 2d vektor olyan vektor, amelynek minden eleme egy-egy vektor. Úgy is nevezhetjük, hogy "vektorok vektora".
Az alábbi példa a 2d Vector-t mutatja be.
import java.util.*; public class Main { public static void main(String args[]) { //definiálunk és inicializálunk egy vektort Vector inner_vec = new Vector(); inner_vec.add("Software"); inner_vec.add("Testing"); inner_vec.add("Java"); inner_vec.add("Tutorials"); //definiálunk egy másik vektort és hozzáadjuk az első vektort. Vector outer_vec = new Vector(); outer_vec.add(inner_vec); String str; //megjelenítjük a vektor tartalmát.vektorok vektora System.out.println("A vektorok vektorának tartalma:"); for(int i=0;iKimenet:
A fenti programban van egy négy elemű vektorunk. Ezután deklarálunk egy másik vektort, és az előző vektort elemként hozzáadjuk a második vektorhoz. Figyeljük meg a vektor elemeinek elérési módját. A for ciklusból következtethetünk arra, hogy a külső vektor első eleme (0 indexen) az első vagy belső vektor.
Így a ciklusban a külső vektor indexét 0-nak tartjuk, és a belső vektoron végighaladva az összes elemet megjelenítjük.
Vektor átalakítása tömbre
Nézzük a következő példát egy Vektor tömbtá alakítására. A Vektor tömbtá alakításához a Vektor osztály 'toArray' metódusát használjuk.
A következő programozási példában , deklarálunk egy string Vector-t, és hozzáadjuk az elemeket. Ezután a Vector osztály toArray metódusával a Vector-t egy String tömbté alakítjuk a string tömb objektum átadásával, mint argumentum.
import java.util.Vector; public class Main { public static void main(String[] args) { // String elemekből álló vektor létrehozása Vector color_vector = new Vector(); // Elemek hozzáadása a vektorhoz color_vector.add("Violet"); color_vector.add("Indigo"); color_vector.add("Blue"); color_vector.add("Green"); color_vector.add("Yellow"); color_vector.add("Orange"); color_vector.add("Red"); //Convertálás Vektorba.String tömb a toArray módszerrel String[] colorsArray = color_vector.toArray(new String[color_vector.size()]); //nyomtatjuk a tömb elemeit System.out.println("String tömb elemei :"); for(String val:colorsArray){ System.out.print(val + " "); } } }Kimenet:
Vektor vs. tömb
Az alábbiakban felsorolunk néhány különbséget a vektorok és a tömbök között.
Vektor Array A vektor dinamikus, mérete az elemek hozzáadásával vagy eltávolításával növekszik és zsugorodik. A tömbök statikusak, és a méretük a deklarálás után is rögzített marad. A vektorok csak objektumokat tárolhatnak. A tömbök primitív típusokat és objektumokat is tárolhatnak. A méret meghatározásához egy size() metódust biztosít. Hosszúsági tulajdonságot biztosít a hossz meghatározásához. Nincs fogalmi dimenzió, de létrehozható vektorok vektoraként, általában 2d vektornak nevezik. A tömbök támogatják a dimenziókat. A vektor szinkronizálva van. A tömb nincs szinkronizálva. A vektor lassabb, mint a tömb. Az array gyorsabb. A kapacitás növelésekor további tárhelyet foglal. Nem foglal további tárolóhelyet. Biztosítja a típusbiztonságot a generikumok támogatásával. Nincs általános támogatás. Vektor vs ArrayList
Ez a szakasz a Vector és az ArrayList közötti különbséget tárgyalja Java-ban.
Vektor ArrayList A Java első verziója óta jelen van (JDK 1.0 verzió). Bevezetve a Java-ban a JDK 1.2 óta A Vector a Java egy örökölt osztálya. Az ArrayList a Java Collections Framework része. A vektor kétszeresére nő, amikor a kapacitása elérte a kétszeresét. Az ArrayList a kapacitásának elérésekor a felére nő. A vektoros módszerek szinkronizáltak. Az ArrayList nem szinkronizált. A Vector Enumerátort és Iterátort használ a bejáráshoz. Az ArrayList csak Iterator-t használ. A vektoros műveletek lassabbak. Az ArrayList gyorsabb. A vektornak van inkrementális mérete, amellyel a vektor mérete növelhető. Az ArrayList nem biztosít növekményméretet. A Vector szálbiztos, ami azt jelenti, hogy a Vector használata több szálból is megengedett és biztonságos. Az ArrayList nem szálbiztos. Gyakran ismételt kérdések
K #1) Mi az a vektor Java-ban?
Válasz: Java-ban a Vektor objektumok növekvő tömbjeként definiálható. A tömbökhöz hasonlóan a Vektor elemei is indexek segítségével érhetők el.
K #2) A vektor rendezett Java-ban?
Válasz: Igen. A Vektor rendezett, és fenntartja az elemek beillesztési sorrendjét.
3. kérdés) A Vector szálbiztos Java-ban?
Válasz: Igen. A Java-ban a Vector osztály szálbiztos. Mivel a Vector osztály szinkronizált, ezért szálbiztos, azaz a Vector osztályt több szálból is használhatja, és az biztonságos.
Q #4) Miért használunk vektort a Java-ban?
Válasz: A legfontosabb ok, amiért a Vektorokat a Java-ban használják, hogy a Vektorok automatikusan nőnek és zsugorodnak. Dinamikusak, ezért előnyben részesítik őket a tömbökkel szemben.
Q #5) Melyik a jobb - ArrayList vagy vektor?
Válasz: Teljesítmény szempontjából az ArrayList gyorsabb, mint a Vector, mivel a Vector szinkronizált és lassabbá teszi.
Következtetés
Ebben a tananyagban a Vektor adatszerkezettel kezdtük a Java-ban. A Vektorok majdnem hasonlítanak egy tömbhöz, amelyben a Vektor elemeket a megszokott indexek segítségével érjük el. A Vektorokat dinamikus tömbnek nevezik, és a tömbökkel ellentétben a Vektor mérete automatikusan növekszik és zsugorodik.
A vektorok rendelkeznek a kapacitás és a növekmény funkcióval is, amelyekkel további tárolóhelyeket hozhatunk létre és foglalhatunk le a jövőbeli kiegészítésekhez. A vektor a Java java.util csomagjának örökölt osztálya, és szinkronizált, valamint szálbiztos.
Ezért a vektorokat kell előnyben részesítenünk, ha dinamikus méretre van szükségünk, és akkor is, ha többszálú környezetben dolgozunk.