what is java vector java vector class tutorial with examples
Questo tutorial spiega tutto sulla struttura dei dati vettoriali in Java con esempi. Imparerai a creare, inizializzare, ordinare e utilizzare un vettore Java nei tuoi programmi:
Un vettore può essere definito come un array dinamico che può crescere o ridursi da solo, cioè il vettore crescerà quando vengono aggiunti più elementi ad esso e si ridurrà quando gli elementi vengono rimossi da esso.
Questo comportamento è diverso da quello degli array statici. Ma in modo simile agli array, è possibile accedere agli elementi vettoriali utilizzando indici interi.
=> Controlla qui per vedere qui i tutorial di formazione su Java dalla A alla Z.
Un vettore può essere visto come simile a un'altra struttura di dati di array dinamici, ArrayList ad eccezione delle due seguenti differenze:
- Il vettore è sincronizzato, ovvero tutti i metodi in Vector sono contrassegnati come 'sincronizzati' e quindi una volta richiamato un metodo, lo stesso metodo non può essere richiamato a meno che la chiamata precedente non sia terminata.
- La classe vector ha molti metodi che non fanno parte del framework delle collezioni ma dei suoi metodi legacy.
Cosa imparerai:
Classe vettoriale Java
Una classe Vector fa parte del ' java.util 'E implementa l'interfaccia List. Un vettore è un array di oggetti o un vettore di oggetti.
Di seguito viene fornita una dichiarazione di classe della classe Vector:
public class Vector extends Object implements List, Cloneable, Serializable Come mostrato sopra, una classe Vector estende ' java.lang.object 'E implementa interfacce List, Cloneable e Serializable.
Come creare un vettore in Java?
È possibile creare un oggetto Vector utilizzando uno dei seguenti metodi di costruzione Vector.
domande e risposte dell'intervista qtp per esperti
| Prototipo del costruttore | Descrizione | |
|---|---|---|
| Chiaro | Void clear () | Cancella il vettore dei suoi elementi. |
| vettore() | Questo è il costruttore predefinito della classe Vector. Crea un vettore vuoto con dimensione 10. | |
| vettore (int initialCapacity) | Questo costruttore sovraccarico costruisce un oggetto Vector vuoto con capacità = initialCapacity. | |
| vector (int initialCapacity, int capacityIncrement) | Questo metodo di costruzione crea un oggetto Vector vuoto con initialCapacity e capacityIncrement specificati. | |
| Vector (Collezione c) | Un oggetto Vector viene creato con gli elementi iniziali della raccolta specificata c. |
Diamo un'occhiata a ciascuno dei costruttori per inizializzare gli oggetti Vector.
Inizializza il vettore
(i) Vettoriale ()
Questo è il costruttore predefinito della classe Vector. Quando si richiama questo costruttore, viene creato un oggetto Vector di dimensione predefinita 10.
La sintassi generale di questo metodo è:
Oggetto vettoriale = nuovo vettore ();
Per esempio,
Vector vec1 = new Vector ();L'istruzione precedente crea un nuovo vettore 'vec1' con dimensione 10.
(ii) Vector (int initialCapacity)
Il costruttore sovraccaricato della classe Vector accetta 'initialCapacity' come argomento. Questo costruttore crea un oggetto Vector con la capacità specificata.
La sintassi generale del metodo è:
Oggetto vettoriale = nuovo vettore (capacità iniziale);
Per esempio,
Vector vec1 = new Vector (10);L'istruzione di programmazione di cui sopra creerà un oggetto Vector 'vec1' con una capacità di 10, ovvero questo Vector può memorizzare fino a 10 elementi.
(iii) Vector (int initialCapacity, int capacityIncrement)
Questo è ancora un altro costruttore sovraccarico della classe Vector e crea un oggetto Vector con la capacità iniziale e l'incremento specificati per la capacità.
La sintassi generale per questo metodo è:
Oggetto Vector = new Vector (initialCapacity, capacityIncrement);
Per esempio,
Vector vec1 = new Vector(5,10);Nell'affermazione precedente, la capacità iniziale del vettore è 5 e l'incremento è 10. Ciò significa che quando 6thelemento viene inserito nel vettore, la capacità del vettore verrà incrementata a 15 (5 + 10). Allo stesso modo, quando il 16thviene inserito l'elemento, la capacità del vettore del Vector verrà estesa a 25 (15 +10).
(iv) Vector (Collezione c)
L'ultimo costruttore sovraccarico della classe Vector accetta una raccolta predefinita come argomento e crea un vettore con tutti gli elementi di questa raccolta come elementi.
La sintassi generale è:
Oggetto vettoriale = nuovo vettore (Collezione c);
Per esempio,
Vector vec1 = new Vector(aList); where aList = {1,2,3,4,5};L'istruzione precedente creerà un vettore 'vec1' con elementi iniziali come {1,2,3,4, 5}.
Tenere a mente tutte queste descrizioni ci consentirà di implementare un programma Vector per comprendere meglio questi costruttori.
Metodi vettoriali in Java
I seguenti sono i metodi supportati dalla classe Vector in Java.
| Nome metodo | Prototipo | Descrizione |
|---|---|---|
| Inserisci | Boolean add (E e) | Aggiunge un dato elemento alla fine del vettore. |
| Void add (int index, E element) | Aggiungi elemento al vettore all'indice specificato. | |
| Aggiungi tutto | Boolean addAll (raccolta c) | Aggiunge tutti gli elementi di una data raccolta alla fine del vettore. |
| Boolean addAll (int index, Collection c) | Aggiunge tutti gli elementi nella raccolta specificata all'indice specificato. | |
| addElement | void addElement (E obj) | Aggiunge l'elemento specificato alla fine del vettore aumentando la dimensione del vettore. |
| Capacità | Capacità int () | Restituisce la capacità corrente del vettore. |
| Clone | Oggetto clone () | Clona il vettore. |
| Contiene | Boolean contiene (Object o) | Controlla se il vettore contiene l'elemento specificato. |
| containsAll | Boolean containsAll (raccolta c) | Controlla se il vettore contiene tutti gli elementi presenti nella raccolta data. |
| copyInto | Void copyInto (Object () anArray) | Copia gli elementi del vettore in un dato array. |
| ElementAt | E ElementAt (int index) | Restituisce l'elemento vettoriale all'indice specificato. |
| Elementi | Enumerationelements () | Restituisce componenti enumerati per il vettore. |
| garantire la capacità | VoiduranceCapacity (int minCapacity) | Aumenta la capacità del vettore per soddisfare la capacità minima specificata. |
| Nome metodo | Prototipo | Descrizione |
|---|---|---|
| insertElementAt | Void insertElementAt (E obj, int index) | Inserisce l'oggetto dato nel vettore all'indice dato. |
| È uguale a | Booleano è uguale a (Oggetto o) | Confronta il vettore corrente con il vettore specificato per verificare se sono uguali. |
| firstElement | E firstElement () | Restituisce il primo elemento del vettore all'indice 0. |
| Ottenere | E get (int indice) | Restituisce l'elemento nel vettore all'indice specificato. |
| codice hash | int hashCode () | Restituisce il valore del codice hash per il vettore. |
| indice di | int indexOf (Oggetto o) | trova l'indice della prima occorrenza dell'elemento dato nel vettore; -1 se l'elemento non è presente nel vettore. |
| int indexOf (Object o, int index) | Cerca il vettore dall'indice dato in avanti per l'elemento specificato; restituisce index se l'elemento viene trovato altrimenti -1 se l'elemento non viene trovato. | |
| è vuoto | Boolean isEmpty () | Controlla se il vettore è vuoto. |
| Iteratore | Iteratoriterator () | Restituisce un iteratore utilizzato per attraversare gli elementi del vettore. |
| lastElement | E lastElement () | Restituisce l'ultimo elemento del vettore. |
| lastIndexOf | Int lastIndexOf (Object o) | Cerca nel vettore l'ultima occorrenza di un dato elemento e restituisce l'indice, oppure restituisce -1 l'elemento non è stato trovato. |
| Int lastIndexOf (Object o, int index) | Inizia la ricerca dell'ultima occorrenza dell'elemento dato dall'indice dato all'indietro. Restituisce l'indice se l'elemento viene trovato altrimenti restituisce -1. | |
| listIterator | ListIteratorlistIterator () | Restituisce un iteratore di lista sugli elementi del vettore. |
| ListIteratorlistIterator (int index) | Restituisce un iteratore di lista sugli elementi del vettore a partire dall'indice dato. |
| Nome metodo | Prototipo | Descrizione |
|---|---|---|
| removeRange | protected void removeRange (int fromIndex, int toIndex) | Elimina tutti gli elementi dal vettore nell'intervallo dato da fromIndex (incluso), totoIndex (esclusivo). |
| Rimuovere | E rimuovi (indice int) | Elimina l'elemento in un dato indice dal vettore. |
| Boolean remove (Object o) | Elimina la prima occorrenza dell'elemento specificato dal vettore. Se l'elemento non è presente, non accade nulla al vettore | |
| Rimuovi tutto | Booleano removeAll (raccolta c) | Elimina tutti gli elementi dal vettore presenti nella raccolta data. |
| void removeAll Elements () | Elimina tutti gli elementi del vettore riducendolo a dimensione zero. | |
| removeElement | Boolean removeElement (Object obj) | Rimuove la prima occorrenza dell'elemento specificato dal vettore. |
| void removeElementAt (int index) | Elimina l'elemento in corrispondenza dell'indice specificato. | |
| keepAll | Boolean keepAll (raccolta c) | Al contrario di 'removeAll', il metodo keepAll conserva gli elementi nel vettore che corrispondono agli elementi nella raccolta specificata. |
| impostato | E set (int index, E element) | Imposta il valore a un dato indice con il nuovo elemento fornito. |
| Void set ElementAt (E obj, int index) | Imposta gli elementi dati in corrispondenza dell'indice specificato. | |
| setSize | Void setSize (int newSize) | Imposta la dimensione data per questo vettore. |
| Taglia | int size () | Restituisce il numero di elementi in questo vettore o la lunghezza del vettore. |
| subList | ListsubList (intfromIndex, inttoIndex) | Restituisce una vista o un sottoelenco del vettore compreso tra fromIndex e toIndex. |
| toArray | Object () toArray () | Converte il vettore dato in un array contenente tutti gli elementi del vettore nell'ordine dato. |
| T () toArray (T () a) | Restituisce un array del tipo specificato contenente tutti gli elementi del vettore. | |
| accordare | String toString () | Restituisce una rappresentazione di stringa del vettore. |
| trimToSize | void trimToSize () | Taglia il vettore per adattarlo alla dimensione corrente. |
Implementazione del vettore
Il seguente programma Java dimostra l'utilizzo di tutti i metodi del costruttore descritti sopra.
import java.util.*; public class Main{ public static void main(String() args) { //Create vectors v1, v2,v3 and v4 Vector v1 = new Vector(); //a vector with default constructor Vector v2 = new Vector(20); // a vector of given Size //initialize vector v2 with values v2.add(10); v2.add(20); v2.add(30); Vector v3 = new Vector(30, 10); // a vector of given Size and Increment // create a vector v4 with given collection List aList = new ArrayList(); aList.add('one'); aList.add('two'); Vector v4 = new Vector(aList); //print contents of each vector 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); } } Produzione:
Il programma sopra ha quattro vettori al suo interno. La prima v1 viene creata con un costruttore predefinito. Il secondo vettore v2 viene creato con capacità iniziale pari a 20. Quindi vengono aggiunti pochi elementi a v2. Il terzo vettore viene creato con una capacità iniziale di 30 e un incremento di 10.
Successivamente, creiamo un ArrayList e creiamo un quarto Vector v4 con ArrayList come argomento. Infine, mostriamo il contenuto di ciascuno di questi vettori.
Notare il contenuto del quarto Vector v4. Poiché abbiamo fornito ArrayList come argomento, il contenuto di ArrayList diventa il contenuto di v4.
Esempio di vettore completo
Ora implementiamo un altro programma che lo farà dimostrare la creazione di vettori, aggiungendovi elementi e mostrandone il contenuto.
import java.util.*; public class Main { public static void main(String args()) { //Create an empty Vector of even numbers Vector evenVector= new Vector (); //Add elements in the vector 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 contents: ' +evenVector); //delete the first occurence of an element 4 using remove method System.out.println('
Firstoccurence of element 4 removed: '+evenVector.remove((Integer)4)); //Display the vector System.out.println('
Vector contents after remove operation: ' +evenVector); //Remove the element at index 4 & display the vector System.out.println('
Remove element at index 4: ' +evenVector.remove(4)); System.out.println('
Vector contents after remove: ' +evenVector); //hashcode for the vector System.out.println('
Hash code of the vector = '+evenVector.hashCode()); //Get the element at index 1 System.out.println('
Element at index 1 is = '+evenVector.get(1)); } } Produzione:
Prendiamo un altro esempio vettoriale. In questo programma, lo faremo usa un vettore di stringa . Manipoliamo questo vettore aggiungendo elementi e quindi stampiamo le sue dimensioni e capacità.
import java.util.*; public class Main { public static void main(String args()) { // create a vector with initial capacity = 2 Vector fruits_vec = new Vector(2); //add elements to the vector fruits_vec.addElement('Grapes'); fruits_vec.addElement('Melon'); fruits_vec.addElement('Kiwi'); fruits_vec.addElement('Apple'); //print current size and capacity of the vector 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()); //print vector elements Enumeration fruits_enum = fruits_vec.elements(); System.out.println('
Vector Elements are:'); while(fruits_enum.hasMoreElements()) System.out.print(fruits_enum.nextElement() + ' '); } }Produzione:
Ordina un vettore
Puoi anche ordinare un vettore in base a un ordine specifico. Per ordinare un vettore, è necessario utilizzare il metodo Collections.sort () di Java Collections Framework.
L'esempio seguente mostra l'ordinamento dei vettori.
import java.util.*; public class Main { public static void main(String arg()) { //Create an empty vector Vector oddVector = new Vector(); //Add elements to the vector oddVector.add(1); oddVector.add(11); oddVector.add(7); oddVector.add(3); oddVector.add(5); //print the vector elements System.out.println('Vector elements: '+oddVector); //sort vector using Collections.sort method Collections.sort(oddVector); //print sorted vector System.out.println('Vector elements after sorting: '+oddVector); } } Produzione:
Il programma precedente crea un vettore di numeri dispari. Quindi, utilizzando il metodo Collections.sort (), il vettore viene ordinato.
Vettore 2D (bidimensionale)
Un vettore 2d è un vettore che ha ciascuno dei suoi elementi come un vettore. Può anche essere definito come 'vettore di vettori'.
Un esempio sotto mostra il 2d Vector.
import java.util.*; public class Main { public static void main(String args()) { //define and initialize a vector Vector inner_vec = new Vector(); inner_vec.add('Software'); inner_vec.add('Testing'); inner_vec.add('Java'); inner_vec.add('Tutorials'); //define another vector and add first vector to it. Vector outer_vec = new Vector(); outer_vec.add(inner_vec); String str; //display the contents of vector of vectors System.out.println('Contents of vector of vectors:'); for(int i=0;i Produzione:
Nel programma sopra, abbiamo un vettore di quattro elementi. Quindi, dichiariamo un altro vettore e aggiungiamo il vettore precedente come elemento al secondo vettore. Notare il modo in cui si accede agli elementi del vettore. Formando il ciclo for, puoi concludere che il primo elemento del vettore esterno (all'indice 0) è il primo o il vettore interno.
Pertanto, nel ciclo, manteniamo l'indice del vettore esterno come 0 e ripetiamo il vettore interno per visualizzare tutti gli elementi.
Converti vettore in array
Consideriamo il seguente esempio di conversione di un vettore in un array. Per convertire un vettore in un array, utilizziamo il metodo 'toArray' della classe Vector.
Nel seguente esempio di programmazione , dichiariamo una stringa Vector e aggiungiamo elementi ad essa. Quindi, utilizzando il metodo toArray della classe Vector, convertiamo il vettore in un array String passando l'oggetto array di stringhe come argomento.
import java.util.Vector; public class Main { public static void main(String() args) { // Create a Vector of String elements Vector color_vector = new Vector(); // Add elements to Vector 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 Vector to String Array using toArray method String() colorsArray = color_vector.toArray(new String(color_vector.size())); //print Array Elements System.out.println('String Array Elements :'); for(String val:colorsArray){ System.out.print(val + ' '); } } } Produzione:
Vector vs array
Di seguito sono elencate alcune delle differenze tra un vettore e un array.
Vettore Vettore Riserva spazio di archiviazione aggiuntivo quando la capacità viene aumentata. Non riserva spazio di archiviazione aggiuntivo. Il vettore è dinamico e le sue dimensioni aumentano e si riducono man mano che gli elementi vengono aggiunti o rimossi. Gli array sono statici e le sue dimensioni rimangono fisse una volta dichiarate. I vettori possono memorizzare solo oggetti. Gli array possono memorizzare sia i tipi primitivi che gli oggetti. Fornisce un metodo size () per determinare la dimensione. Fornisce la proprietà length per determinare la lunghezza. Nessuna dimensione concettuale ma può essere creato come vettore di vettori, normalmente chiamato vettore 2d. Gli array supportano le dimensioni. Il vettore è sincronizzato. L'array non è sincronizzato. Il vettore è più lento dell'array. Array è più veloce. Garantisce la sicurezza del tipo supportando i farmaci generici. Nessun supporto generico.
Vector vs ArrayList
Questa sezione discute la differenza tra Vector e ArrayList in Java.
Vettore Lista di array Il vettore ha una dimensione di incremento in base alla quale è possibile aumentare la dimensione del vettore. ArrayList non fornisce la dimensione dell'incremento. Presente dalla versione iniziale di Java (versione JDK 1.0). Introdotto in Java a partire da JDK 1.2 Vector è una classe legacy di Java. ArrayList è una parte di Java Collections Framework. Il vettore cresce del doppio delle sue dimensioni quando viene raggiunta la sua capacità. ArrayList cresce della metà delle dimensioni quando viene raggiunta la sua capacità. I metodi vettoriali sono sincronizzati. ArrayList non è sincronizzato. Vector utilizza Enumerator e Iterator per l'attraversamento. ArrayList utilizza solo Iterator. Le operazioni sui vettori sono più lente. ArrayList è più veloce. Vector è thread-safe, il che significa che l'utilizzo di Vector da più thread è consentito ed è sicuro. ArrayList non è thread-safe.
Domande frequenti
D # 1) Che cos'è un vettore in Java?
Risposta: In Java, un vettore può essere definito come un array espandibile di oggetti. Analogamente agli array, è possibile accedere agli elementi Vector anche utilizzando gli indici.
D # 2) Il vettore è ordinato in Java?
Risposta: Sì. Un vettore viene ordinato e mantiene l'ordine di inserimento degli elementi.
D # 3) Vector è thread-safe in Java?
script di test di esempio per il test del software
Risposta: Sì. In Java la classe Vector è thread-safe. Poiché la classe Vector è sincronizzata, la rende thread-safe, cioè puoi usare la classe Vector da più thread ed è sicura.
D # 4) Perché usiamo il vettore in Java?
Risposta: Il motivo più importante per cui Vector viene utilizzato in Java è che un vettore cresce e si restringe automaticamente. Sono dinamici per cui sono preferiti agli array.
Q # 5) Quale è meglio - ArrayList o vettore?
Risposta: Dal punto di vista delle prestazioni, ArrayList è più veloce rispetto a Vector poiché Vector è sincronizzato e lo rende più lento.
Conclusione
In questo tutorial, abbiamo iniziato con la struttura dati Vector in Java. I vettori sono quasi simili a un array in cui si accede agli elementi Vector utilizzando indici familiari. I vettori sono chiamati array dinamici e, a differenza degli array, la dimensione del vettore aumenta e si riduce automaticamente.
I vettori hanno anche la capacità e le funzionalità di incremento che possono essere utilizzate per creare e riservare spazio di archiviazione aggiuntivo per future aggiunte. Vector è una classe legacy nel pacchetto java.util di Java ed è sincronizzata e thread-safe.
Pertanto, dovremmo preferire i vettori quando abbiamo bisogno di dimensioni dinamiche e anche mentre lavoriamo in un ambiente multi-thread.
=> Visita qui per l'esclusiva serie di tutorial di formazione Java.
Lettura consigliata
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Tutorial Java Reflection con esempi
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Jagged Array in Java - Tutorial con esempi
- Tutorial sulla lunghezza di array Java con esempi di codice
- Come ordinare un array in Java - Tutorial con esempi
- Parola chiave Java 'questo': tutorial con esempi di codice
- Modificatori di accesso in Java - Tutorial con esempi
