La classe Vector implementa una serie espandibile di oggetti. I vettori rientrano nelle classi legacy, ma ora sono completamente compatibili con le raccolte. Si trova dentro pacchetto java.util e implementare il Elenco interfaccia, quindi possiamo utilizzare tutti i metodi dell'interfaccia Elenco come mostrato di seguito come segue:
- Vector implementa un array dinamico, il che significa che può crescere o ridursi secondo necessità. Come un array, contiene componenti a cui è possibile accedere utilizzando un indice intero.
- Sono molto simili a Lista di array , ma Vector è sincronizzato e dispone di alcuni metodi legacy che il framework della raccolta non contiene.
- Mantiene anche un ordine di inserimento come un ArrayList. Tuttavia, viene utilizzato raramente in un ambiente non thread così com'è sincronizzato e, per questo motivo, offre prestazioni scadenti nell'aggiunta, ricerca, eliminazione e aggiornamento dei suoi elementi.
- Gli Iteratori restituiti dalla classe Vector sono fail-fast. In caso di modifica simultanea, fallisce e lancia il file ConcurrentModificationException.
Sintassi:
public class Vector extends AbstractList implements List, RandomAccess, Cloneable, Serializable>
Qui, E è il tipo di elemento.
- Si estende AbstractList e implementa Elenco interfacce.
- Implementa interfacce Serializable, Cloneable, Iterable, Collection, List, RandomAccess.
- La sottoclasse direttamente conosciuta è Pila .
I punti importanti riguardanti l'incremento della capacità del vettore sono i seguenti:
Se viene specificato l'incremento, Vector si espanderà in base ad esso in ogni ciclo di allocazione. Tuttavia, se l’incremento non viene specificato, la capacità del vettore viene raddoppiata in ogni ciclo di allocazione. Vector definisce tre membri dati protetti:
- incremento capacità int: Contiene il valore di incremento.
- conteggio elementi int: Numero di elementi attualmente memorizzati nel vettore.
- Elemento oggettoData[]: L'array che contiene il vettore è memorizzato al suo interno.
Gli errori comuni nella dichiarazione dei vettori sono i seguenti segue :
- Vector lancia un IllegalArgumentException se la dimensione iniziale del vettore definito è negativa.
- Se la raccolta specificata è nulla, genera un'eccezione NullPointerException .
Costruttori
1. Vettore(): Crea un vettore predefinito la cui capacità iniziale è 10.
Vector v = new Vector();>
2. Vettore (dimensione intera): Crea un vettore la cui capacità iniziale è specificata dalla dimensione.
Vector v = new Vector(int size);>
3. Vettore(int size, int incr): Crea un vettore la cui capacità iniziale è specificata da size e l'incremento è specificato da incr. Specifica il numero di elementi da allocare ogni volta che un vettore viene ridimensionato verso l'alto.
booleano in c
Vector v = new Vector(int size, int incr);>
4. Vettore (raccolta c): Crea un vettore che contiene gli elementi della collezione c.
Vector v = new Vector(Collection c);>
Metodi nella classe Vector
METODO | DESCRIZIONE |
|---|---|
| add(E e) | Aggiunge l'elemento specificato alla fine di questo Vector. |
| add(int indice, elemento E) | Inserisce l'elemento specificato nella posizione specificata in questo Vector. |
addAll(Raccolta estende E> c) | Aggiunge tutti gli elementi nella Collection specificata alla fine di questo Vector, nell'ordine in cui vengono restituiti dall'Iteratore della Collection specificata. |
addAll(int indice, Raccolta c) | Inserisci tutti gli elementi nella raccolta specificata in questo vettore nella posizione specificata. |
| addElement(E oggetto) | Aggiunge il componente specificato alla fine di questo vettore, aumentandone la dimensione di uno. |
| capacità() | Restituisce la capacità corrente di questo vettore. |
| chiaro() | Rimuove tutti gli elementi da questo Vector. |
| clone() | Restituisce un clone di questo vettore. |
| contiene(Oggetto o) | Restituisce vero se questo vettore contiene l'elemento specificato. |
| contieneTutto(Collezione c) | Restituisce vero se questo Vector contiene tutti gli elementi nella Collection specificata. |
| copyInto (Oggetto [] anArray) | Copia i componenti di questo vettore nell'array specificato. |
| elementoAt(int indice) | Restituisce il componente in corrispondenza dell'indice specificato. |
| elementi() | Restituisce un'enumerazione dei componenti di questo vettore. |
| GuaranteeCapacità(int MinCapacità) | Aumenta la capacità di questo vettore, se necessario, per garantire che possa contenere almeno il numero di componenti specificati dall'argomento della capacità minima. |
| uguale(Oggetto o) | Confronta l'oggetto specificato con questo vettore per verificarne l'uguaglianza. |
| primoElemento() | Restituisce il primo componente (l'elemento con indice 0) di questo vettore. |
perEach(Consumatore super E> azione) istruzione di stampa in Java | Esegue l'azione specificata per ciascun elemento dell'Iterable fino a quando tutti gli elementi non sono stati elaborati o l'azione genera un'eccezione. |
| get(indice int) | Restituisce l'elemento nella posizione specificata in questo Vector. |
| codice hash() | Restituisce il valore del codice hash per questo vettore. |
| indiceDi(Oggetto o) | Restituisce l'indice della prima occorrenza dell'elemento specificato in questo vettore, o -1 se questo vettore non contiene l'elemento. |
| indiceOf(Oggetto o, indice int) | Restituisce l'indice della prima occorrenza dell'elemento specificato in questo vettore, effettuando una ricerca in avanti dall'indice, oppure restituisce -1 se l'elemento non viene trovato. |
| insertElementAt(E oggetto, indice int) | Inserisce l'oggetto specificato come componente in questo vettore nell'indice specificato. |
| è vuoto() | Verifica se questo vettore non ha componenti. |
| iteratore() | Restituisce un iteratore sugli elementi in questo elenco nella sequenza corretta. |
| ultimoelemento() | Restituisce l'ultimo componente del vettore. |
| ultimoIndiceOf(Oggetto o) | Restituisce l'indice dell'ultima occorrenza dell'elemento specificato in questo vettore, o -1 se questo vettore non contiene l'elemento. comando nel nodo js |
| lastIndexOf(Oggetto o, indice int) | Restituisce l'indice dell'ultima occorrenza dell'elemento specificato in questo vettore, effettuando una ricerca all'indietro dall'indice, oppure restituisce -1 se l'elemento non viene trovato. |
| elencoIteratore() | Restituisce un iteratore di elenco sugli elementi in questo elenco (nella sequenza corretta). |
| listIterator(int indice) | Restituisce un iteratore di lista sugli elementi in questa lista (nella sequenza corretta), a partire dalla posizione specificata nell'elenco. |
| rimuovi(indice int) | Rimuove l'elemento nella posizione specificata in questo Vector. |
| rimuovi(Oggetto o) | Rimuove la prima occorrenza dell'elemento specificato in questo Vector. Se il Vector non contiene l'elemento, rimane invariato. |
| rimuoviTutto(Raccolta c) | Rimuove da questo Vector tutti i suoi elementi contenuti nella Collection specificata. |
| rimuoviTuttiGliElementi() | Rimuove tutti i componenti da questo vettore e ne imposta la dimensione su zero. |
| rimuoviElemento(Oggetto oggetto) | Rimuove la prima occorrenza (con l'indice più basso) dell'argomento da questo vettore. |
| rimuoviElementoAt(int indice) | Elimina il componente in corrispondenza dell'indice specificato. |
| rimuoviSe(filtro predicato) | Rimuove tutti gli elementi di questa raccolta che soddisfano il predicato specificato. |
rimuoviIntervallo(int daIndice, int all'Indice) | Rimuove da questo elenco tutti gli elementi il cui indice è compreso tra fromIndex, inclusivo e toIndex, esclusivo. |
| replaceAll(operatore UnaryOperator) | Sostituisce ogni elemento di questo elenco con il risultato dell'applicazione dell'operatore a quell'elemento. |
| keepAll(Raccolta c) | Mantiene solo gli elementi in questo Vector contenuti nella Collection specificata. |
| set(indice int, elemento E) | Sostituisce l'elemento nella posizione specificata in questo Vector con l'elemento specificato. |
| setElementAt(E oggetto, indice int) | Imposta il componente all'indice specificato di questo vettore come oggetto specificato. |
| setSize(int newSize) | Imposta la dimensione di questo vettore. |
| misurare() | Restituisce il numero di componenti in questo vettore. |
| sort(Comparatore c) | Ordina questo elenco in base all'ordine indotto dal comparatore specificato. |
| divisore() | Crea uno Spliterator con associazione tardiva e fail-fast sugli elementi in questo elenco. |
| sottoLista(int dall'Indice, int all'Indice) | Restituisce una visualizzazione della parte di questo elenco compresa tra fromIndex, compreso, e toIndex, esclusivo. |
| toArray() | Restituisce un array contenente tutti gli elementi di questo Vector nell'ordine corretto. |
| toArray(T[] a) | Restituisce un array contenente tutti gli elementi di questo Vector nell'ordine corretto; il tipo di runtime dell'array restituito è quello dell'array specificato. |
| accordare() | Restituisce una rappresentazione stringa di questo Vector, contenente la rappresentazione String di ciascun elemento. |
| tagliare alla dimensione() | Taglia la capacità di questo vettore in modo che corrisponda alla dimensione corrente del vettore. |
Discutiamo e implementiamo innanzitutto come creare e utilizzare un Vector prima di approdare ai metodi di questa classe.
Esempio:
Giava // Java Program to Demonstrate Working of Vector // Via Creating and Using It // Importing required classes import java.io.*; import java.util.*; // Main class class GFG { // Main driver method public static void main(String[] args) { // Size of the Vector int n = 5; // Declaring the Vector with // initial size n Vector v = nuovo vettore (N); // Aggiunge nuovi elementi alla // fine del vettore for (int i = 1; i<= n; i++) v.add(i); // Printing elements System.out.println(v); // Remove element at index 3 v.remove(3); // Displaying the vector // after deletion System.out.println(v); // iterating over vector elements // using for loop for (int i = 0; i < v.size(); i++) // Printing elements one by one System.out.print(v.get(i) + ' '); } }> Produzione
[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>
Nota:
- Se l'incremento del vettore non è specificato, la sua capacità verrà raddoppiata in ogni ciclo di incremento.
- La capacità di un vettore non può essere inferiore alla dimensione, può essere uguale ad essa.
Esecuzione di varie operazioni sulla classe Vector in Java
Parliamo di varie operazioni sulla classe Vector elencate come segue:
- Aggiunta di elementi
- Aggiornamento degli elementi
- Rimozione di elementi
- Iterazione sugli elementi
Operazione 1: Aggiunta di elementi
Per aggiungere gli elementi al Vector, utilizziamo il file aggiungere() metodo. Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi. Sono elencati di seguito come segue:
cosa rende veloce un pc
- aggiungi(Oggetto): Questo metodo viene utilizzato per aggiungere un elemento alla fine del Vector.
- add(int indice, Oggetto): Questo metodo viene utilizzato per aggiungere un elemento a un indice specifico nel Vector.
Esempio:
Giava // Java Program to Add Elements in Vector Class // Importing required classes import java.io.*; import java.util.*; // Main class // AddElementsToVector class GFG { // Main driver method public static void main(String[] arg) { // Case 1 // Creating a default vector Vector v1 = new Vector(); // Adding custom elements // using add() method v1.add(1); v1.add(2); v1.add('geeks'); v1.add('forGeeks'); v1.add(3); // Printing the vector elements to the console System.out.println('Vector v1 is ' + v1); // Case 2 // Creating generic vector Vector v2 = nuovo Vettore (); // Aggiunta di elementi personalizzati // utilizzando il metodo add() v2.add(1); v2.add(2); v2.add(3); // Stampa gli elementi vettoriali sulla console System.out.println('Vector v2 is ' + v2); } }> Produzione:
Vector v1 is [1, 2, geeks, forGeeks, 3] Vector v2 is [1, 2, 3]>
Operazione 2: Aggiornamento degli elementi
Dopo aver aggiunto gli elementi, se desideriamo modificare l'elemento, possiamo farlo utilizzando il file impostato() metodo. Poiché un vettore è indicizzato, l'elemento che desideriamo modificare viene referenziato dall'indice dell'elemento. Pertanto, questo metodo accetta un indice e l'elemento aggiornato da inserire in tale indice.
Esempio
Giava // Java code to change the // elements in vector class import java.util.*; // Driver Class public class UpdatingVector { // Main Function public static void main(String args[]) { // Creating an empty Vector Vector vec_tor = nuovo vettore (); // Usa il metodo add() per aggiungere elementi nel vettore vec_tor.add(12); vec_tor.add(23); vec_tor.add(22); vec_tor.add(10); vec_tor.add(20); // Visualizzazione del vettore System.out.println('Vector: ' + vec_tor); // Utilizzo del metodo set() per sostituire 12 con 21 System.out.println('L'oggetto sostituito è: ' + vec_tor.set(0, 21)); // Utilizzo del metodo set() per sostituire 20 con 50 System.out.println('L'oggetto sostituito è: ' + vec_tor.set(4, 50)); // Visualizzazione del vettore modificato System.out.println('Il nuovo vettore è:' + vec_tor); } }> Produzione
Vector: [12, 23, 22, 10, 20] The Object that is replaced is: 12 The Object that is replaced is: 20 The new Vector is:[21, 23, 22, 10, 50]>
Operazione 3: Rimozione di elementi
Per rimuovere un elemento da un vettore, possiamo usare il comando rimuovere() metodo. Questo metodo è sovraccaricato per eseguire più operazioni in base a parametri diversi. Sono:
- rimuovi(Oggetto): Questo metodo viene utilizzato per rimuovere un oggetto dal Vector. Se sono presenti più oggetti di questo tipo, viene rimossa la prima occorrenza dell'oggetto.
- rimuovi(int indice): Poiché un Vector è indicizzato, questo metodo assume un valore intero che rimuove semplicemente l'elemento presente in quell'indice specifico nel Vector. Dopo aver rimosso l'elemento, tutti gli elementi vengono spostati a sinistra per riempire lo spazio e gli indici degli oggetti vengono aggiornati.
Esempio
Giava // Java code illustrating the removal // of elements from vector import java.util.*; import java.io.*; class RemovingElementsFromVector { public static void main(String[] arg) { // Create default vector of capacity 10 Vector v = new Vector(); // Add elements using add() method v.add(1); v.add(2); v.add('Geeks'); v.add('forGeeks'); v.add(4); // Removing first occurrence element at 1 v.remove(1); // Checking vector System.out.println('after removal: ' + v); } }> Produzione:
after removal: [1, Geeks, forGeeks, 4]>
Operazione 4: Iterazione del vettore
Esistono diversi modi per scorrere il vettore. Il modo più famoso è utilizzare il ciclo for di base in combinazione con a Ottenere() metodo per ottenere l'elemento in un indice specifico e il avanzato per un ciclo .
Esempio
Giava // Java program to iterate the elements // in a Vector import java.util.*; public class IteratingVector { public static void main(String args[]) { // create an instance of vector Vectorv = nuovo vettore(); // Aggiungi elementi utilizzando il metodo add() v.add('Geeks'); v.add('Geek'); v.add(1, 'Per'); // Utilizzando il metodo Get e il // ciclo for for (int i = 0; i< v.size(); i++) { System.out.print(v.get(i) + ' '); } System.out.println(); // Using the for each loop for (String str : v) System.out.print(str + ' '); } }> Produzione
Geeks For Geeks Geeks For Geeks>
Nota: Dai una lettura a Classe ArrayList vs Vector in Java per coglierlo meglio.
In Java, la classe Vector fa parte del Java Collections Framework e fornisce un'implementazione di array dinamico dell'interfaccia List. È stato aggiunto nella versione originale di Java (Java 1.0) e fornisce numerosi metodi per manipolare gli elementi di un vettore, inclusi l'aggiunta, l'inserimento e la rimozione di elementi.
tutorial java jfx
Ecco un semplice esempio che dimostra come utilizzare un vettore in Java:
Giava import java.util.Vector; public class VectorExample { public static void main(String[] args) { // Create a new vector Vector v = nuovo Vettore(3, 2); // Aggiunge elementi al vettore v.addElement(1); v.addElement(2); v.addElement(3); // Inserisce un elemento nell'indice 1 v.insertElementAt(0, 1); // Rimuove l'elemento all'indice 2 v.removeElementAt(2); // Stampa gli elementi del vettore for (int i : v) { System.out.println(i); } } }> Produzione
1 0 3>
Tieni presente che la classe Vector è sincronizzata, il che significa che più thread possono accedere allo stesso vettore senza causare problemi. Tuttavia, questa sincronizzazione va a scapito delle prestazioni, quindi se non è necessario condividere un vettore tra più thread, generalmente è meglio utilizzare una classe alternativa come ArrayList che non è sincronizzata.
Vantaggi dell'utilizzo di Vector in Java:
- Sincronizzazione: come accennato in precedenza, Vector è sincronizzato, rendendolo sicuro da utilizzare in un ambiente multi-thread.
- Dimensione dinamica: la dimensione di un vettore può aumentare o ridursi dinamicamente man mano che gli elementi vengono aggiunti o rimossi, quindi non devi preoccuparti di impostare una dimensione iniziale che possa ospitare tutti gli elementi.
- Supporto legacy: Vector fa parte di Java sin dal suo inizio ed è ancora supportato, quindi è una buona opzione se devi lavorare con codice Java precedente che utilizza Vector.
Svantaggi dell'utilizzo di Vector in Java:
- Prestazioni: la sincronizzazione in Vector può portare a prestazioni più lente rispetto ad altre classi di raccolta, come ArrayList.
- Codice legacy: sebbene Vector sia ancora supportato, il codice Java più recente viene spesso scritto utilizzando le classi di raccolta più moderne, quindi potrebbe essere più difficile trovare esempi e supporto per Vector.
- Overhead non necessario: se non hai bisogno delle funzionalità di sincronizzazione di Vector, il suo utilizzo aggiungerà un sovraccarico non necessario al tuo codice.
Libro di consultazione
Un buon libro di riferimento per conoscere Java Collections Framework e Vector è Java Collections di Naftalin e Wadler. Questo libro fornisce uno sguardo completo al framework delle raccolte Java, incluso Vector, e include molti esempi ed esercizi per aiutarti a capire come utilizzare queste classi in modo efficace.