La classe Vector

La classe Vector du package java.util permet de stocker des objets dans un tableau dont la taille évolue avec les besoins.

Utilisation

Constructeurs

Parmi les constructeurs disponibles, l'un n'attend aucun paramètre, l'autre attend une taille initiale en paramètre. On construira donc un objet vect de la classe Vector en écrivant simplement:

        Vector vect=new Vector();

ou

        Vector vect=new Vector(n);

pour prévoir une capacité initiale de n.

Ajouter un objet

On ajoute un objet à la fin du Vector en utilisant la méthode addElement. Par exemple, pour ajouter l'objet o, on écrira :

        vect.addElement(o);

Le premier élément ajouté a l'indice 0, le suivant l'indice 1, etc... La méthode size() renvoie le nombre d'éléments contenus dans le vecteur qui sera aussi l'indice du prochain objet ajouté.

Lire un objet

On retrouve un objet à partir de son indice en utilisant la méthode elementAt. Par exemple on obtient l'objet d'indice n en écrivant :

        o=vect.elementAt(n);

Attention, la méthode elementAt renvoie par défaut des objets de type Object, un transtypage est souvent nécessaire. Par exemple, si l'élément d'indice 2 est de type String, il faudra écrire :

        Color c=(Color)vect.elementAt(2);

Autres méthodes

La classe Vector contient de nombreuses autres méthodes qui rendent son utilisation très aisée. Notons :

• contains(Object) : indique si l'objet est contenu dans le Vector.
• copyInto(Object[]) : copie les éléments dans un tableau classique.
• firstElement() : renvoie le premier élément.
• indexOf(Object) : renvoie l'indice de l'objet
• insertElementAt(Object, int) : insère l'objet à l'indice indiqué
• isEmpty() : indique si le Vector est vide
• lastElement() : renvoie le dernier élément
• removeAllElements() : vide le Vector
• removeElementAt(int) : retire l'objet dont l'indice est donné
• setElementAt(Object, int) : place l'objet à l'indice donné
• size() : renvoie le nombre d'éléments

L'applet glossaire

Nous allons construire une applet qui joue le rôle d'un glossaire. L'ensemble des mots du glossaire et de leurs définitions seront tirés d'un fichier et rangés dans un objet de type Vector.

Format du fichier de données

Le fichier de données est un fichier texte dans lequel chaque ligne contient un mot et sa définition séparés par le signe =.

Déclarations

On importe les packages nécessaires, on implémente l'interface ItemListener pour les choix dans la liste des mots, on prépare les composants et un Vector glo qui contiendra toutes les lignes du fichier de données.

        import java.applet.*;
        import java.awt.*;
        import java.awt.event.*;
        import java.io.*;
        import java.net.*;
        import java.util.*;

        public class glossaire extends Applet 
         implements ItemListener {
 
         //fichier de données
         String nomFichier="glossaire.txt";
         //TextArea avec WordWrap
         TextArea zoneTexte=new TextArea
          ("",10,30,TextArea.SCROLLBARS_VERTICAL_ONLY);
         //Liste des mots du glossaire
         List liste=new List();
         //Structure de stockage des données
         Vector glo=new Vector();

Méthode init

On place les composants et on récupère le nom du fichier de données.

         public void init() {
          //positionnement des composants
          setLayout(new BorderLayout(4,4));
          add("Center",zoneTexte);
          zoneTexte.setEditable(false);
          zoneTexte.setBackground(Color.white);  
          add("West",liste);
          //propriétés de la liste
          liste.addItemListener(this);
          liste.setMultipleMode(false);
          liste.setBackground(Color.white);
          //nom du fichier de données
          String nom=getParameter("fichier");
          if (nom!=null) nomFichier=nom;
         }

Lecture du fichier de données

On peut lire le fichier de données dans la méthode start.

         public void start() {
          //lecture du fichier
          try {
           URL url=new URL(getCodeBase(),nomFichier);
           BufferedReader br=new BufferedReader
              (new InputStreamReader(url.openStream()));
           String ligne;   
           while (null!=(ligne = br.readLine()))
            if (ligne.indexOf('=')>0) glo.addElement(ligne);
           br.close();                
          } catch (Exception e) {}
          //remplissage de la liste
          for (int i=0; i<glo.size(); i++) 
           liste.addItem(nom(i));
          //sélection initiale
          liste.select(0);
          affiche(def(0));
          liste.requestFocus();
         }

On a utilisé les méthodes nom et affiche qui permettent d'extraire un mot du glossaire et d'afficher sa définition. Il faut écrire ces méthodes.

Méthodes d'utilisation du glossaire

La méthode nom(int n) renvoie le mot d'indice n, la méthode affiche(int n) affiche sa définition. On sépare les deux parties en utilisant la position du signe =.

         String nom(int n) {
         //retrouver le n ième mot de la liste
          if (n>=0 && n<glo.size()) {
           String S=(String)glo.elementAt(n);
           int pos=S.indexOf('=');
           return S.substring(0,pos);
          }
          else return "";
         }
 
         void affiche(int n) {
         //retrouver la n ième définition
          if (n>=0 && n<glo.size()) {
           String S=(String)glo.elementAt(n);
           int pos=S.indexOf('=');
           S=S.substring(pos+1,S.length());
           //affichage, les # sont remplacés par des retours chariots
           S=S.replace('#','\n');
           zoneTexte.setText(S);
          } 
         }

Choix dans la liste

Il reste à écrire la méthode itemStateChanged de gestion des évènements produits par la liste.

 public void itemStateChanged(ItemEvent e) {
  if (e.getStateChange()==ItemEvent.SELECTED) {
   affiche(liste.getSelectedIndex());
  }
 }