Java vecteur

Vous avez probablement déjà rencontré des tableaux en Java et vous savez que l'un de leurs principaux inconvénients est la constance de la taille. Une fois que vous avez créé un tableau d'une certaine taille, vous ne pouvez pas le modifier ultérieurement. Il existe plusieurs classes de framework Java Collection dans le langage Java qui résolvent ce problème. L'un d'eux est Java Vector Class. Il sera discuté dans cet article.

Qu'est-ce que la classe vectorielle

Comme nous l'avons écrit dans la préface, la classe Vector de Java Collection Framework élimine le problème de la taille statique des tableaux. Java Vector est une sorte de tableau dynamique et peut augmenter ou réduire sa taille. En utilisant la classe de collection Vector , nous pouvons stocker un groupe d'éléments sous forme d'objets simples et les manipuler via les différentes méthodes. La classe Vector est disponible dans le package java.util . Ainsi, Vector en Java peut être utilisé si vous ne connaissez pas la taille du tableau à l'avance, ou si vous avez besoin d'un "tableau" qui peut changer de dimension au cours de la durée de vie du programme. Il faut dire tout de suite que le VectorLa classe est déjà assez ancienne, et des collections ultérieures sont apparues qui peuvent la remplacer dans la grande majorité des cas. L'"analogue" populaire de Java Vector est la classe ArrayList . La différence la plus importante entre ces classes est que Vector est synchronisé, alors que ArrayList ne l'est pas. Nous parlerons d'autres différences entre ces deux classes et des analogues plus modernes de la classe Vector un peu plus tard dans la section "Qu'est-ce qui ne va pas avec la classe Vector".

Méthodes vectorielles Java

Voici les méthodes vectorielles Java :

• void add(int index, Object element) insère l'élément spécifié à la position spécifiée du vecteur.

• boolean add(Object o) ajoute l'élément spécifié à la fin du vecteur.

• boolean addAll(Collection c) ajoute tous les éléments de la collection spécifiée à la fin du vecteur, dans l'ordre dans lequel ils sont renvoyés par l'itérateur de collection spécifié.

• boolean addAll(int index, Collection c) insère tous les éléments de la Collection spécifiée dans le vecteur à la position spécifiée.

• void addElement(Object obj) ajoute le composant spécifié à la fin de ce vecteur, augmentant sa taille de un.

• int capacity() renvoie la capacité actuelle de ce vecteur.

• void clear() supprime tous les éléments de ce vecteur.

• Object clone() renvoie un clone de ce vecteur.

• boolean contains(Object elem) teste si l'objet spécifié est un composant de ce vecteur.

• boolean containsAll(Collection c) renvoie true si le vecteur contient tous les éléments de la Collection spécifiée.

• void copyInto(Object[] anArray) copie les composants de ce vecteur dans le tableau spécifié.

• L'objet elementAt(int index) renvoie le composant à l'index spécifié.

• Enumeration elements() renvoie une énumération des composants de ce vecteur.

• voidassureCapacity(int minCapacity) augmente la capacité de ce vecteur, si nécessaire, pour s'assurer qu'il peut contenir au moins le nombre de composants donné par l'argument de capacité minimale.

• boolean equals(Object o) compare l'objet spécifié à ce vecteur.

• L'objet firstElement() renvoie la première composante (élément à l'index 0) de ce vecteur.

• Object get(int index) renvoie l'élément à la position spécifiée dans ce vecteur.

• int hashCode() renvoie la valeur du code de hachage pour ce vecteur.

• int indexOf(Object elem) recherche la première occurrence de l'argument donné, en testant l'égalité à l'aide de la méthode equals.

• int indexOf(Object elem, int index) recherche la première occurrence de l'argument donné, en commençant à index et en testant l'égalité à l'aide de la méthode equals.

• void insertElementAt(Object obj, int index) insère l'objet spécifié en tant que composant dans ce vecteur à l'index spécifié.

• boolean isEmpty() teste ce vecteur pour les composants manquants.

• L'objet lastElement() renvoie la dernière composante du vecteur.

• int lastIndexOf(Object elem) renvoie l'index de la dernière occurrence de l'objet spécifié dans ce vecteur.

• int lastIndexOf(Object elem, int index) recherche en arrière l'objet spécifié, en commençant à l'index spécifié, et lui renvoie l'index.

• Object remove(int index) supprime l'élément à la position spécifiée dans ce vecteur.

• boolean remove(Object o) supprime la première occurrence de l'élément spécifié dans ce vecteur. Si le vecteur ne contient pas d'élément, il ne change pas.

• booléen removeAll(Collection c) supprime tous les éléments du vecteur contenus dans la Collection spécifiée.

• void removeAllElements() supprime tous les composants du vecteur et définit sa taille à zéro.

• boolean removeElement(Object obj) supprime la première occurrence (indice le plus bas) de l'argument de ce vecteur.

• void removeElementAt(int index) supprime un élément à index.

• protected void removeRange(int fromIndex, int toIndex) supprime de cette liste tous les éléments dont l'index est compris entre fromIndex, inclus, et toIndex, exclusivement.

• boolean keepAll(Collection c) conserve uniquement les éléments du vecteur contenus dans la Collection spécifiée.

• Object set(int index, Object element) remplace l'élément à la position spécifiée dans ce vecteur par l'élément spécifié.

• void setElementAt(Object obj, int index) définit le composant à l'index spécifié de ce vecteur comme objet donné.

• void setSize(int newSize) définit la taille de ce vecteur.

• int size() renvoie le nombre de composants dans ce vecteur.

• List subList(int fromIndex, int toIndex) renvoie une représentation (vue) de la partie de cette liste entre fromIndex, inclus, et toIndex, exclusivement.

• Object[] toArray() renvoie un tableau contenant tous les éléments de ce vecteur dans le bon ordre.

• Object[] toArray(Object[] a) renvoie un tableau contenant tous les éléments de ce vecteur dans le bon ordre ; le type d'exécution du tableau retourné est le type du tableau spécifié.

• String toString() renvoie une représentation sous forme de chaîne de ce vecteur contenant une représentation sous forme de chaîne de chaque élément.

• void trimToSize() ajuste la capacité de ce vecteur à la taille actuelle du vecteur.

Exemple de vecteur 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());

   }
}

La sortie de ce programme est ci-dessous :

Qu'est-ce qui ne va pas avec la classe vectorielle ?

Selon la documentation de la classe Java Vector , si vous n'avez pas besoin d'une implémentation thread-safe dans votre programme, il est recommandé d'utiliser ArrayList à la place de Vector (Collection Framework participant plus efficace). Modifions un peu l'exemple ci-dessus, en utilisant la classe ArrayList au lieu de 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());

       }
   }

Nous avons commenté la ligne avec vector.indexOf("Johnny", 1) , car il n'y a pas une telle méthode dans cette variation de la classe ArrayList . Pour la même raison, la ligne vector.firstElement() a été commentée. À tous autres égards, le programme produit le même résultat que le premier. Bien sûr, dans un tel exemple, on ne sait pas pourquoi ArrayList est meilleur que Vector . Cela nécessite plus de connaissances sur, par exemple, les threads. Nous énumérons ici les raisons. Tout d'abord, bien que la classe Vector soit synchronisée, elle ne peut pas être qualifiée de complètement thread-safe, bien que cela semble étrange. Le fait est que Vector synchronise chaque opération, pas la totalité du Vectorinstance elle-même. Cela peut être un problème dans les programmes où vous devez synchroniser l'ensemble des opérations plutôt que des opérations individuelles. Supposons que si un thread itère sur un vecteur et qu'un autre thread modifie structurellement une instance du vecteur, l'itérateur lèvera une ConcurrentModificationException . Il s'avère que deux threads peuvent fonctionner avec une instance Vector en même temps s'ils effectuent des opérations différentes. Deuxièmement, le vecteurLa classe n'a pas les meilleures performances car ses objets ont un tableau redimensionnable et une synchronisation. Cette combinaison signifie une surcharge supplémentaire pour les opérations de blocage, que la synchronisation soit requise ou non. Bien sûr, cela affecte les performances. De plus, la synchronisation du vecteur sur chaque opération a également un effet négatif sur les performances, puisque nous allons acquérir un verrou encore et encore pour chaque opération. Si l'intégralité de l'instance de la classe était synchronisée, le verrou serait également acquis une fois, ce qui est beaucoup plus efficace. Troisièmement, Vector prend en charge certaines méthodes héritées. Par exemple éléments(). Cette méthode renvoie une énumération des composants du vecteur. Les programmeurs utilisent le plus souvent Iterator ou ListIterator to Enumeration, et pour un certain nombre de raisons. En particulier, Enumeration n'a pas de méthode remove() définie, ce qui signifie que la liste ne peut pas être structurellement modifiée pendant l'itération. De plus, contrairement à ListIterator, Enumeration n'offre pas d'accès bidirectionnel. Comme vous pouvez le voir, Vector a pas mal de problèmes. Et si vous avez toujours besoin d'une implémentation thread-safe de l'interface List ? Dans ce cas, ArrayList n'aidera pas, mais vous pouvez utiliser, par exemple, la classe CopyOnWriteArrayList au lieu de Vector ; il est positionné comme une variante thread-safe de ArrayList. Vous pouvez également synchroniser ArrayList à l'aide de la méthode Collections synchronizedList() .

Vector a vraiment des problèmes... pourquoi est-il toujours en Java et pourquoi devrait-il être enseigné ?

La question se pose : pourquoi étudions-nous la classe Vector ? Et pourquoi n'a-t-il pas encore été supprimé de Java ? Le fait est que Java professe le principe de la rétrocompatibilité. Cela signifie que tout ancien code écrit il y a de nombreuses années sera compris par les versions modernes de Java. En outre, il existe un certain nombre d'applications d'entreprise dans l'environnement Java qui sont prises en charge depuis des décennies. Il est tout à fait possible que vous deviez faire face à un tel «dinosaure» dans votre travail, vous devez donc vous préparer à des surprises, telles que du code avec des classes héritées inefficaces.