Vettore di Giava

Probabilmente ti sei già imbattuto in array in Java e sai che uno dei loro principali svantaggi è la costanza delle dimensioni. Una volta che hai creato un array di una certa dimensione, non puoi cambiarlo in seguito. Esistono diverse classi del framework Java Collection nel linguaggio Java che risolvono questo problema. Uno di questi è Java Vector Class. Se ne parlerà in questo articolo.

Cos'è la classe vettoriale

Come abbiamo scritto nella prefazione, la classe Vector di Java Collection Framework elimina il problema della dimensione statica degli array. Java Vector è una sorta di array dinamico e può crescere o ridursi di dimensioni. Utilizzando la classe di raccolta Vector , possiamo memorizzare un gruppo di elementi come oggetti semplici e manipolarli attraverso i vari metodi. La classe Vector è disponibile nel pacchetto java.util . Pertanto, Vector in Java può essere utilizzato se non si conosce in anticipo la dimensione dell'array o se è necessario un "array" che può modificare le dimensioni durante la durata del programma. Va detto subito che il Vectorclass è già piuttosto vecchia e in seguito sono apparse raccolte che possono sostituirla nella stragrande maggioranza dei casi. Il popolare "analogo" di Java Vector è la classe ArrayList . La differenza più importante tra queste classi l'una dall'altra è che Vector è sincronizzato, mentre ArrayList no. Parleremo di altre differenze tra queste due classi e analoghi più moderni della classe Vector un po' più avanti nella sezione "Cosa c'è che non va nella classe Vector".

Metodi vettoriali Java

Ecco i metodi vettoriali Java :

• void add(int index, Object element) inserisce l'elemento specificato nella posizione specificata del vettore.

• boolean add(Object o) aggiunge l'elemento specificato alla fine del vettore.

• boolean addAll(Collection c) aggiunge tutti gli elementi nella raccolta specificata alla fine del vettore, nell'ordine in cui vengono restituiti dall'iteratore della raccolta specificato.

• boolean addAll(int index, Collection c) inserisce tutti gli elementi all'interno della Collection specificata nel vettore nella posizione specificata.

• void addElement(Object obj) aggiunge il componente specificato alla fine di questo vettore, aumentandone la dimensione di uno.

• int capacity() restituisce la capacità corrente di questo vettore.

• void clear() rimuove tutti gli elementi da questo vettore.

• Object clone() restituisce un clone di questo vettore.

• boolean contains(Object elem) verifica se l'oggetto specificato è un componente in questo vettore.

• boolean containsAll(Collection c) restituisce true se il vettore contiene tutti gli elementi della Collection specificata.

• void copyInto(Object[] anArray) copia i componenti di questo vettore nell'array specificato.

• L'oggetto elementAt(int index) restituisce il componente all'indice specificato.

• Enumeration elements() restituisce un'enumerazione dei componenti di questo vettore.

• void sureCapacity(int minCapacity) aumenta la capacità di questo vettore, se necessario, per garantire che possa contenere almeno il numero di componenti dato dall'argomento capacità minima.

• boolean equals(Object o) confronta l'oggetto specificato con questo vettore.

• Object firstElement() restituisce il primo componente (elemento all'indice 0) di questo vettore.

• Object get(int index) restituisce l'elemento nella posizione specificata in questo vettore.

• int hashCode() restituisce il valore del codice hash per questo vettore.

• int indexOf(Object elem) cerca la prima occorrenza dell'argomento dato, verificando l'uguaglianza usando il metodo equals.

• int indexOf(Object elem, int index) cerca la prima occorrenza dell'argomento dato, a partire da index, e verifica l'uguaglianza usando il metodo equals.

• void insertElementAt(Object obj, int index) inserisce l'oggetto specificato come componente in questo vettore in corrispondenza dell'indice specificato.

• boolean isEmpty() verifica questo vettore per i componenti mancanti.

• L'oggetto lastElement() restituisce l'ultimo componente del vettore.

• int lastIndexOf(Object elem) restituisce l'indice dell'ultima occorrenza dell'oggetto specificato in questo vettore.

• int lastIndexOf(Object elem, int index) cerca all'indietro l'oggetto specificato, partendo dall'indice specificato, e restituisce l'indice ad esso.

• Object remove(int index) rimuove l'elemento nella posizione specificata in questo vettore.

• boolean remove(Object o) rimuove la prima occorrenza dell'elemento specificato in questo vettore. Se il vettore non contiene un elemento, non cambia.

• boolean removeAll(Collection c) rimuove dal vettore tutti gli elementi contenuti nella Collection specificata.

• void removeAllElements() rimuove tutti i componenti dal vettore e ne imposta la dimensione a zero.

• boolean removeElement(Object obj) rimuove la prima occorrenza (indice più basso) dell'argomento da questo vettore.

• void removeElementAt(int index) rimuove un elemento in index.

• protected void removeRange(int fromIndex, int toIndex) rimuove da questo List tutti gli elementi il ​​cui indice è compreso tra fromIndex, incluso, e toIndex, esclusivamente.

• boolean retainAll(Collection c) conserva solo gli elementi nel vettore contenuti nella Collection specificata.

• Object set(int index, Object element) sostituisce l'elemento nella posizione specificata in questo vettore con l'elemento specificato.

• void setElementAt(Object obj, int index) imposta il componente all'indice specificato di questo vettore come oggetto dato.

• void setSize(int newSize) imposta la dimensione di questo vettore.

• int size() restituisce il numero di componenti in questo vettore.

• List subList(int fromIndex, int toIndex) restituisce una rappresentazione (visualizzazione) della parte di questa List compresa tra fromIndex, inclusivo, e toIndex, esclusivamente.

• Object[] toArray() restituisce un array contenente tutti gli elementi di questo vettore nell'ordine corretto.

• Object[] toArray(Object[] a) restituisce un array contenente tutti gli elementi di questo vettore nell'ordine corretto; il tipo di esecuzione dell'array restituito è il tipo dell'array specificato.

• String toString() restituisce una rappresentazione di stringa di questo vettore contenente una rappresentazione di stringa di ciascun elemento.

• void trimToSize() ritaglia la capacità di questo vettore alla dimensione corrente del vettore.

Esempio di vettore Java

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

   }
}

L'output di questo programma è qui sotto:

Cosa c'è che non va nella classe vettoriale?

Secondo la documentazione della classe Java Vector , se non è necessaria un'implementazione thread-safe nel programma, si consiglia di utilizzare ArrayList al posto di Vector (partecipante più efficace di Collection Framework). Cambiamo un po' l'esempio sopra, usando la classe ArrayList invece di 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());

       }
   }

Abbiamo commentato la riga con vector.indexOf("Johnny", 1) , perché non esiste un metodo di questo tipo in questa variazione nella classe ArrayList . Per lo stesso motivo, la riga vector.firstElement() è stata commentata. Sotto tutti gli altri aspetti, il programma produce lo stesso risultato del primo. Naturalmente, in un esempio del genere, non è chiaro perché ArrayList sia migliore di Vector . Ciò richiede una maggiore conoscenza, ad esempio, dei thread. Elenchiamo qui i motivi. In primo luogo, sebbene la classe Vector sia sincronizzata, non può essere definita completamente thread-safe, anche se questo sembra strano. Il fatto è che Vector sincronizza ogni operazione, non l'intero Vectoristanza stessa. Questo può essere un problema nei programmi in cui è necessario sincronizzare l'intero insieme di operazioni piuttosto che le singole operazioni. Diciamo, se un thread sta iterando su un vettore e un altro thread sta modificando strutturalmente un'istanza del vettore, l'iteratore genererà un'eccezione ConcurrentModificationException . Si scopre che due thread possono funzionare contemporaneamente con un'istanza Vector se eseguono operazioni diverse. In secondo luogo, il vettoreclass non ha le migliori prestazioni perché i suoi oggetti hanno un array ridimensionabile e la sincronizzazione. Questa combinazione comporta un sovraccarico aggiuntivo per le operazioni di blocco, indipendentemente dal fatto che la sincronizzazione sia necessaria o meno. Certo, questo influisce sulle prestazioni. Inoltre, la sincronizzazione del vettore su ogni operazione ha anche un effetto negativo sulle prestazioni, poiché acquisiremo ripetutamente un blocco per ogni operazione. Se l'intera istanza della classe fosse sincronizzata, anche il blocco verrebbe acquisito una volta, il che è molto più efficiente. In terzo luogo, Vector supporta alcuni metodi legacy. Ad esempio elementi(). Questo metodo restituisce un'enumerazione dei componenti del vettore. I programmatori usano più spesso Iterator o ListIterator per l'enumerazione e per una serie di motivi. In particolare, Enumeration non ha un metodo remove() definito, il che significa che l'elenco non può essere modificato strutturalmente durante l'iterazione. Inoltre, a differenza di ListIterator, Enumeration non offre l'accesso bidirezionale. Come puoi vedere, Vector ha parecchi problemi. Cosa succede se hai ancora bisogno di un'implementazione thread-safe dell'interfaccia List? In questo caso, ArrayList non aiuta, ma puoi usare, ad esempio, la classe CopyOnWriteArrayList invece di Vector ; è posizionato come variante thread-safe di ArrayList. È inoltre possibile sincronizzare ArrayList utilizzando il metodo CollectionssynchronedList() .

Il vettore ha davvero dei problemi ... perché è ancora in Java e perché dovrebbe essere insegnato?

La domanda sorge spontanea: perché stiamo studiando la classe Vector ? E perché non è stato ancora rimosso da Java? Il fatto è che Java professa il principio della retrocompatibilità. Ciò significa che tutto il vecchio codice scritto molti anni fa sarà compreso dalle versioni moderne di Java. Inoltre, ci sono parecchie applicazioni di livello aziendale nell'ambiente Java che sono state supportate per decenni. È del tutto possibile che dovrai affrontare un simile "dinosauro" nel tuo lavoro, quindi devi essere preparato a sorprese, come il codice con classi legacy inefficaci.