La classe Vector permet de créer une collection d'objets qui fonctionne de la même manière qu'un tableau, à l'exception que sa capacité peut varier en fonction des besoins.

Une allocation de mémoire dynamique est utilisée par les objets Vector, si bien qu'il est possible d'ajouter, de supprimer aisément leurs éléments, soit de faire varier leur taille dynamiquement.

De cette manière, un vecteur peut stocker un nombre quelconque d'objets de type Object, soit n'importe quel genre d'objets (String, Integer, URL, Date, etc.). Par contre, un vecteur n'accepte pas les valeurs de types primitifs qui doivent être converties en objet par l'intermédiaire de leur classe Wrappers (double -> Double, char -> Character, etc.).

Bien qu'il soit possible d'ajouter des objets instances de diverses classes, il n'est pas recommandé d'utiliser cette particularité puisque la gestion de la collection deviendrait vite problématique lors notamment, d'opérations de consultation et surtout d'exploitation.

Un vecteur comporte quatre constructeurs permettant d'initialiser les instances de cette classe.

Le premier permet de créer un vecteur initialement vide auquel il sera possible d'ajouter des éléments via une méthode spécifique.

Vector vecteur = new Vector();

Le second permet d'initialiser le vecteur à une certaine taille fournie en argument. Dans ce cas, la valeur contenu par chacun des éléments est null. Cependant, cette initialisation peut poser des problèmes de gestion d'espace mémoire, car un vecteur initialisé à n éléments voit sa capacité doublée lorsqu'un dépassement de sa capacité initiale intervient.

Vector vecteur = new Vector(50);

import java.util.*;
class Vecteur {
    public static void main(String args[]) {
        Vector vecteur = new Vector(10);
        // Affiche 10
        System.out.println ("Taille du vecteur : " + vecteur.capacity());
        for(int i = 0; i < vecteur.capacity(); i++)
            vecteur.add(i, new Integer(1900 + i));
        vecteur.add(vecteur.size(), new Integer(1900 + 11));
        // Affiche 20
        System.out.println ("Nombre d'éléments : " + vecteur.size());
        System.out.println ("Taille du vecteur : " + vecteur.capacity());
    }
}

Le troisième permet d'initialiser le vecteur à une certaine capacité le vecteur tout en veillant également à définir un pas d'incrémentation de sa capacité suite à un dépassement, palliant ainsi à la contrainte du constructeur précédent.

Vector vecteur = new Vector(100, 10);

Enfin, le quatrième permet de construire un vecteur à partir d'une collection passée en argument. Cette collection doit implémenter l'interface Collection, à l'image de ArrayList, HashSet, LinkedHashSet, LinkedList, TreeSet et même Vector.

Vector vecteur = new Vector(collection);

import java.util.*;
class Vecteur {
    public static void main(String args[]) {
       ArrayList collection = new ArrayList();
       collection.add("lundi");
       collection.add("mardi");
       collection.add("mercredi");
       collection.add("jeudi");
       collection.add("vendredi");
       collection.add("samedi");
       collection.add("dimanche");
       Vector vecteur = new Vector(collection);
       for(int i = 0; i < vecteur.size(); i++)
           System.out.println (vecteur.elementAt(i));
       //Affiche 7
       System.out.println ("Taille du vecteur : " + vecteur.size());
    }
}

Deux méthodes permettent respectivement de récupérer la capacité et la taille d'un vecteur. Evidemment, ces deux dernières fournissent des informations différentes. La capacité correspond à la longueur du tableau de données interne conservé dans le champ elementData d'un vecteur, alors que la taille reflète le nombre d'éléments effectif contenu dans le champ elementCount du vecteur.

int capacite = vecteur.capacity();

int taille = vecteur.size();

Par ailleurs, la classe Vector dispose d'autres méthodes destinées à modifier les caractéristiques d'un objet vecteur. Il s'agît de setSize(int taille) déterminant une nouvelle taille pour le vecteur, ensureCapacity(int capacite) augmentant la capacité du vecteur si nécessaire, ainsi que trimToSize() adaptant la capacité à la taille courante du vecteur.

vecteur.setSize(100);

vecteur.ensureCapacity(vecteur.capacity() + 50);

vecteur.trimToSize();

L'ajout d'objets dans un vecteur s'accompli par l'intermédiaire de plusieurs méthodes dont la plupart sont préfixées par add.

  • La méthode void add(int index, Object element) insère un élément à la position spécifiée.
    vecteur.add(3, "Une chaîne");
  • La méthode boolean add(Object obj) ajoute un élément à la fin du vecteur.
    boolean reussi = vecteur.addAll(liste);
  • La méthode boolean addAll(Collection col) ajoute une collection d'éléments à la fin du vecteur.
    boolean reussi = vecteur.addAll(colllectionObjets);
  • La méthode boolean addAll(int index, Collection col) ajoute une collection d'éléments à l'index spécifié dans le vecteur.
    boolean reussi = vecteur.addAll(2, colObjets);
  • La méthode void addElement(Object obj) ajoute un objet à la fin du vecteur.
    vecteur.addElement(String[]);
  • La méthode void insertElementAt(Object obj, int index) insère un objet à l'index spécifié du vecteur.
    vecteur.insertElementAt("Lundi", 1);

La suppression est prise en charge par plusieurs méthodes de la classe Vector commençant en général par remove. La suppression d'un ou plusieurs éléments entraîne une réorganisation du vecteur, c'est-à-dire que l'emplacement d'un élement effacé et immédiatement remplacé par l'élément suivant et cela en cascade jusqu'au dernier élément du vecteur.

  • la méthode Object remove(int index) supprime l'objet à l'index spécifié et le retourne.
    Object element = vecteur.remove(5);
  • La méthode boolean remove(Object obj) supprime la première occurrence de l'objet trouvée dans le vecteur.
    boolean reussi = vecteur.remove("mardi");
  • La méthode boolean removeAll(Collection col) supprime tous les éléments de la collection qui sont contenus dans le vecteur.
    boolean reussi = vecteur.removeAll(liste);
  • La méthode void removeAllElements() supprime tous les éléments et remet à zéro la taille du vecteur.
    vecteur.removeAllElements();
  • La méthode boolean removeElement(Object obj) supprime la première occurrence de l'élément du vecteur.
    boolean reussi = vecteur.removeElement("mercredi");
  • La méthode void removeElementAt(int index) efface l'élément à l'index spécifié.
    vecteur.removeElementAt(4);
  • La méthode protected void removeRange(int debut, int fin) supprime les éléments situés dans un intervalle spécifié par les arguments.
    vecteur.removeRange(2, 6);
  • La méthode void clear() supprime tous les éléments dans le vecteur.
    vecteur.clear();
  • La méthode boolean retainAll(Collection col) retient les éléments de la collection et supprime tous les autres du vecteur.
    boolean reussi = 
                        vecteur.retainAll(vecteur.subList(1, 5));
public class Vecteur {
    public static void main(String[] args) {
        Vector vecteur = new Vector();
        vecteur.add("lundi");
        vecteur.add("mardi");
        vecteur.add("mercredi");
        vecteur.add("jeudi");
        vecteur.add("Vendredi");
        Vector v1 = new Vector(vecteur);
        Vector v2 = new Vector(vecteur);
        v1.removeAllElements();
        v2.clear();
        System.out.println ("La taille du vecteur (1, 2) : " 
                                          + v1.size() + ", " + v1.size() );
        System.out.println ("La capacité du vecteur (1, 2) : " 
                                          + v1.capacity() + ", " + v1.capacity());
    }
}

La consultation des éléments présents dans une collection Vector s'effectue par l'intermédiaire de diverses méthodes permettant de récupérer un élément précis ou plusieurs.

La méthode Object elementAt(int index) retourne l'élément trouvé à l'index spécifié.

String obj = (String)vecteur.elementAt(5);

La méthode Enumeration elements() retourne la liste de tous les éléments du vecteur dans un objet Enumeration.

import java.util.*;
public class Vecteur {
    public static void main(String[] args) {
        Vector vecteur = new Vector();
        vecteur.add("lundi");
        vecteur.add("mardi");
        vecteur.add("mercredi");
        vecteur.add("jeudi");
        vecteur.add("vendredi");
        for (Enumeration enum = vecteur.elements(); 
                             enum.hasMoreElements();)
            System.out.println(enum.nextElement());
    }
}

Les méthodes Object firstElement() et Object lastElement() retournent respectivement le premier et le dernier élément du vecteur.

//Retourne l'élément à l'index 0
Object objPremier = vecteur.firstElement();
//Retourne l'élément à l'index vecteur.size() - 1
Object objDernier = vecteur.lastElement();

Les méthodes Object[] toArray() et Object[] toArray(Object[] obj) retournent un tableau d'objets contenant les éléments du vecteur. La seconde méthode remplit le tableau passé en argument et retourne également un tableau de même contenu que le premier. Ainsi dans ce cas, il est inutile d'utiliser la valeur de retour de cette méthode.

import java.util.*;
public class Vecteur {
    public static void main(String[] args) {
        Vector vecteur = new Vector();
        vecteur.add("lundi");
        vecteur.add("mardi");
        vecteur.add("mercredi");
        vecteur.add("jeudi");
        vecteur.add("vendredi");
        Object[] tabCh2 = new Object[10];
        Object[] tabCh = vecteur.toArray(tabCh2);
        for(int i = 0; i < tabCh.length; i++)
            System.out.println (tabCh[i]);
        for(int i = 0; i < tabCh2.length; i++)
            System.out.println (tabCh2[i]);
    }    
}

La méthode subList(int debut, int fin) extrait une liste d'éléments du vecteur depuis un index de début et jusqu'à un index de fin exclus.

//Extraction des éléments de l'indice 1 à 4.
List liste = vecteur.subList(1, 5);
//Retourne le troisième élément
Object o = liste.get(3);

Les méthodes Iterator iterator(), ListIterator listIterator() et Listiterator listIterator(int debut) de la classe abstraite AbstractList, retournent respectivement des objets Iterator et ListIterator contenant tous les éléments du vecteur ou une partie depuis le début de ce dernier.

import java.util.*;
class Vecteur {
    public static void main(String args[]) {
        Vecto collection = new Vector();
        collection.add("lundi");
        collection.add("mardi");
        collection.add("mercredi");
        collection.add("jeudi");
        collection.add("vendredi");
        collection.add("samedi");
        collection.add("dimanche");
        Iterator i = collection.iterator();
        System.out.println ("  Iterator");
        while(i.hasNext())
            System.out.println (i.next().toString());
        ListIterator li = collection.listIterator();
        System.out.println ("  ListIterator");
        while(li.hasNext())
            System.out.println (li.next().toString());
        ListIterator li2 = collection.listIterator(3);
        System.out.println ("  ListIterator 2");
        while(li2.hasNext())
            System.out.println (li2.next().toString());
    }
}

Les moyens de contrôler la présence d'un ou plusieurs éléments sont assurés par plusieurs méthodes prenant comme argument l'objet recherché et parfois un index de démarrage de la recherche.

La méthode boolean contains(Object obj) vérifie si l'objet spécifié est contenu dans le vecteur.

boolean reussi = vecteur.contains("mercredi");

La méthode boolean containsAll(Collection col) teste si tous les éléments de la collection spécifiée sont contenus dans le vecteur.

import java.util.*;
class Vecteur {
    public static void main(String args[]) {
        Vector collection = new Vector();
        collection.add("lundi");
        collection.add("mardi");
        collection.add("mercredi");
        collection.add("jeudi");
        collection.add("vendredi");
        collection.add("samedi");
        collection.add("dimanche");
        ArrayList tableau = new ArrayList();
        tableau.add("mercredi");
        tableau.add("samedi");
        tableau.add("dimanche");
        if(collection.containsAll(tableau))
            System.out.println ("La liste est bien "
                                + "contenue dans le vecteur !");
    }
}

Les méthodes int indexOf(Object obj) et int lastIndexOf(Object obj) recherchent respectivement la première et la dernière occurrence d'un objet donné en testant l'égalité entre les objets à l'aide de la méthode equals().

//retourne -1 puisque non-trouvé
int position = vecteur.indexOf("Samedi");
//retourne 5
int position = vecteur.lastIndexof("samedi");

Les méthodes int indexOf(Object obj, int index) et int lastIndexOf(Object obj, int index) recherchent respectivement la première et la dernière occurrence d'un objet donné en démarrant à une certaine position et en s'appuyant sur la méthode equals().

import java.util.*;
class Vecteur {
  public static void main(String args[]) {
    Vector collection = new Vector();
    collection.add("Belgique");
    collection.add("Allemagne");
    collection.add("Espagne");
    collection.add("France");
    collection.add("France");
    collection.add("Italie");
    collection.add("France");
    int position = 0;
    while(position < collection.size() 
                                                && position > -1){
      //Si "France".equals("France"); 
      //alors position > -1
      position = collection.indexOf("France", 
                                                                    position);
      System.out.println ("France : " + position++);
    }
  }
}

Le parcours des éléments d'un objet Vector peuvent se faire en utilisant une boucle, ou en appliqant un itérateur sur les éléments de la liste.

for(int i = 0; i < liste.size(); i++){
    Object element = liste.get(i);
}
// itérateur
Iterator iterateur = liste.iterator();
while(iterateur.hasNext()){
    Object element = iterateur.next();
}
// itérateur de liste
ListIterator iterateur = liste.listIterator();
while(iterateur.hasNext()){
    Object element = iterateur.next();
}

L'objet ListIterator possède plusieurs méthodes supplémentaires efficaces dans la gestion des listes, par rapport à une implémentation de l'interface Iterator surtout utilisée dans le cadre des ensembles (Set). Ainsi, il est possible de parcourir une liste dans les deux directions possibles.

// parcours du bas vers le haut
ListIterator iterateur = liste.listIterator();
while(iterateur.hasPrevious()){
    Object element = iterateur.previous();
}
// parcours du haut vers le bas
ListIterator iterateur = liste.listIterator();
while(iterateur.hasNext()){
    Object element = iterateur.next();
}

D'autre part, les méthodes permettent de retourner l'index suivant (nextIndex()) ou précédent (previousIndex()), de supprimer (remove()), d'ajouter (add()) et de remplacer (set()) des éléments.

Tous les exemples de la page [voir]