Vector, Iterator, LinkedList

Java fournit la classe Vector dans sont package java.util Un objet de la classe Vector est similaire à un tableau puisqu’il permet de stocker plusieurs valeurs. Contrairement aux tableaux, un Vector ne requiert pas la manipulation d’indices pour gérer ses éléments. Cette gestion se fait à travers les méthodes de cette classe.

Efficacité des vecteurs : Une différence importante entre les tableaux et les vecteurs est que ces derniers gèrent implicitement leurs taille, celle-ci peut changer automatiquement lors de l’exécution du programme s’il manque de place pour un nouvel élément. Par contre, l’implémentation de la classe Vector utilise (implicitement) un tableau. Lorsque nous insérons un nouvel élément ailleurs qu’à la fin, tous ceux qui le suivront seront d’abord décalés, un à un, d’une position dans le vecteur, ce qui ralenti l’exécution du programme. Lorsque le traitement à faire demande beaucoup d’insertions et de suppressions d’éléments, un vecteur risque de s’avérer moins efficace que, par exemple une liste chaînée.

Les informations plus complètes se trouvent au lien : http://java. sun Constructor Summary Vector() Constructs an empty vector so that its internal data array has size 10 and its standard capacity increment is zero. Vector<Collection>() Constructs a vector containing the elements of the specified collection, in the order they are returned by the collection's iterator. Vector(int initialCapacity) Constructs an empty vector with the specified initial capacity and with its capacity increment equal to zero. Vector(int initialCapacity, int capacityIncrement) Constructs an empty vector with the specified initial capacity and capacity increment. 

Ajout d'un nouvel élément : Cercle c1 = new Cercle(1.5), Vector <Cercle> cercle = new Vector<Cercle> (); Avec ces déclarations : cercle est un vecteur vide (pas d'éléments), sa taille vaut zéro : cercle.size() vaut 0 Ajout d'un nouvel élément : Cercle c1 = new Cercle(1.5), c2 = new Cercle(4.2); cercle.addElement(c1); cercle.addElement(c2); Après ces 2 ajouts : cercle.size() vaut 2

Cercle c = (Cercle) cercle.elementAt(1); Accès à un élément : Cercle c = (Cercle) cercle.elementAt(1); Modifier un élément (utile pour le tri) Supposons qu'on dispose d'un vecteur de 12 cercles. Cercle nouvCercle = new Cercle(7.7); cercle.setElementAt(nouvCercle, 6); La deuxième ligne mémorise le nouveau cercle dans le vecteur à l'indice 6.

Supposons qu'on dispose d'un vecteur de 12 cercles. Insertion un élément : Supposons qu'on dispose d'un vecteur de 12 cercles. Cercle nouvCercle = new Cercle(10.4); cercle.insertElementAt(nouvCercle, 10); Le nouveau cercle prend sa place à l'indice 10 et pousse les deux autres vers le bas du vecteur. La taille devient 13.

Suppression : public final boolean removeElement (E obj); Si l'objet est un élément du vecteur : . supprimer la première occurrence . déplacer certains éléments vers le haut . décrémente la taille du vecteur . retourne true Si non : . retourne false public final void removeElementAt(int indice); Supprimer l'élément à l'indice spécifié s'il existe et faire des ajustements en conséquence. public final void removeAllElements(); Retirer tous les élements et mettre sa taille à 0

Recherche : public final int indexOf (E obj); retourne l'indice de la première occurrence de l’élément trouvé (-1 si non trouvé) public final int lastIndexOf (E obj); retourne l'indice de la dernière occurrence de l’élément trouvé (-1 si non trouvé) public final boolean contains (E obj); retourne true si l’élément donné est un élément de ce vecteur (false sinon).

Conversion en chaîne de caractères : public String toString() retourne une chaîne représentant le vecteur. Tester si le vecteur est vide : public boolean isEmpty()

import java.util.*; public class Vect1{ public static void main(String args[]){ Vector<Object> vect = new Vector<Object>(5); vect.addElement(new Integer(3)); vect.addElement(new String("Bonjour")); vect.addElement(new Float(3.14)); System.out.println("taille du vecteur : " + vect.size()); System.out.println("capacité du vecteur : " + vect.capacity()); System.out.println(vect); for(int i=0; i<vect.size(); i++) if(vect.elementAt(i) != null) System.out.println("vect[" + i + "] : " + vect.elementAt(i).getClass().getName() + " --> " + vect.elementAt(i)); else System.out.println("vect[" + i + "] est null"); if(vect.elementAt(1) != null){ vect.set(1, new Integer(1000)); } System.out.println("après : " + vect); vect.remove(0); System.out.println("après remove : " + vect + " et taille = " + vect.size());

taille du vecteur : 3 capacité du vecteur : 5 [3, Bonjour, 3.14] vect[0] : java.lang.Integer --> 3 vect[1] : java.lang.String --> Bonjour vect[2] : java.lang.Float --> 3.14 après : [3, 1000, 3.14] après remove : [1000, 3.14] et taille = 2

Autre exemple : public class Cercle { private double rayon ; public Cercle (double rayon) { this.rayon = rayon; } public double perimetre() { return 2 * Math.PI * rayon; public double surface() { return Math.PI * Math.pow(rayon, 2.0); public String toString() { return "rayon : " + rayon + ", perimetre = " + String.format("%5.2f",perimetre()) + ", surface = " + String.format("%5.2f",surface()) + "\n";

import java.util.*; /* pour utiliser la classe Vector */ /** classe Vector, informations de base * Fichier Vect2.java et Cercle.java * */ public class Vect2 { static void afficher (Vector<Cercle> c, String message) { System.out.println(message); if (c.size() == 0) System.out.println("Le vecteur est vide"); else { System.out.println("Le vecteur contient " + c.size() + " element(s)"); for (int i = 0 ; i < c.size(); i++) { System.out.print(" a l'indice " + i + ") "); System.out.print(c.elementAt(i)); }

public static void main (String[] args) { Vector<Cercle> c = new Vector<Cercle> (); afficher(c, "\nApres l'instruction : Vector c = new Vector(); "); Cercle c1 = new Cercle(10.2), c2 = new Cercle(1.7); /* 2 méthodes équivalentes pour insérer à la fin */ c.addElement(c1); c.add(c2); afficher(c, "\nApres avoir ajoute les deux cercles c1 et c2 : "); Cercle c3 = new Cercle(5.4); c.insertElementAt(c3, 1); // c.add(1,c3); /* équivalent à la ligne précédente */ afficher(c, "\nApres avoir insere le cercle c3 a l'indice 1 : "); System.out.print("\n numero 1 "); System.out.println(c.firstElement()); System.out.println("Indice du cercle c3 : " + c.indexOf(c3)); Cercle c4 = new Cercle (44.4); c.setElementAt(c4, 0); // c.set(0,c4); /* équivalent à la ligne précédente */ afficher(c, "\nApres avoir remplace l'element a l'indice 0 par c4 : "); c.removeElementAt(1); // c.remove(1) /* semblable à la ligne précédente */ afficher(c, "\nApres avoir retire l'element a l'indice 1 : "); } // fin main } // fin Vect2

Apres l'instruction : Vector c = new Vector(); Le vecteur est vide Apres avoir ajoute les deux cercles c1 et c2 : Le vecteur contient 2 element(s) a l'indice 0) rayon : 10.2, perimetre = 64,09, surface = 326,85 a l'indice 1) rayon : 1.7, perimetre = 10,68, surface = 9,08 Apres avoir insere le cercle c3 a l'indice 1 : Le vecteur contient 3 element(s) a l'indice 1) rayon : 5.4, perimetre = 33,93, surface = 91,61 a l'indice 2) rayon : 1.7, perimetre = 10,68, surface = 9,08 numero 1 rayon : 10.2, perimetre = 64,09, surface = 326,85 Indice du cercle c3 : 1 Apres avoir remplace l'element a l'indice 0 par c4 : a l'indice 0) rayon : 44.4, perimetre = 278,97, surface = 6193,21 Apres avoir retire l'element a l'indice 1 :

Fichier d’objets et Vector import java.io.*; import java.util.*; class Personne implements Serializable{ private String nom; private int age; Personne(String nom, int age){ this.nom=nom; this.age=age;} public String toString(){ return nom + ", " + age ; } } // fin Personne class Employe extends Personne{ Employe(String nom, int age){ super(nom,age);} return "<Employé: " + super.toString() + ">"; } // fin Employe class Cadre extends Personne{ Cadre(String nom, int age){ super(nom,age);} return "<Cadre: " + super.toString() + ">"; }// fin Cadre

public class LireEcrireObjet{ public static void main(String [] args) throws Exception{ ObjectOutputStream ficPerson = new ObjectOutputStream ( new FileOutputStream("Personnes.obj")); Vector <Personne> vPersonnes= new Vector <Personne>(); // ajout des personnes vPersonnes.add(new Cadre("Durant", 50)); vPersonnes.add(new Employe("Gaston", 33)); // écriture dans fichier ficPerson.writeObject(vPersonnes); ficPerson.close(); ObjectInputStream ficObj = new ObjectInputStream ( new FileInputStream("Personnes.obj")); // lecture du fichier et affichage vPersonnes = (Vector<Personne>) ficObj.readObject(); for (int i=0; i < vPersonnes.size(); i++){ System.out.println(vPersonnes.elementAt(i)); } // fin for } // fin main } // fin classe

Listes chaînées Une liste chaînée est une liste dont chaque élément est relié au suivant par une référence à ce dernier. Une liste chaînée peut être utilisée dans le cadre d'une simulation de pile ou de file, FIFO(First In First Out) ou FILO(First In Last Out). La taille d'une LinkedList n'est pas fixe : on peut ajouter et enlever des éléments selon nos besoins. Nous pouvons aussi remarquer que les LinkedList acceptent tous types d'objets. Pour bien comprendre le principe des listes chaînées, rien de mieux qu'un petit schéma :

Chaque élément contient une référence sur son suivant. On remarque que la queue n'a pas de suivant. Son suivant est en fait null. Voici l'exemple d'opérations sur une liste chaînée : List maListe=new LinkedList() ; // on crée notre liste chaînée maListe.add(new Integer(1)) ; // on ajoute l'entier 1 maListe.add(new Float(2.15)) ; // on ajoute le flottant 2.15 à la liste /* On remarque ici que l'entier 1 est la tête de la liste, et que le float est la queue de la liste. */ Integer monEntier=(Integer)maListe.getFirst() ; // on n'oublie pas de faire le cast Float monFloat=(Float)maListe.getLast(); // on n'oublie pas de faire le cast maListe.remove(0) ; // on retire l'entier , le flottant devient la tete

Les opérations principales sur une liste chaînée sont : add(Object o) : ajoute un objet o en fin de liste addFirst(Object o) : ajoute un objet o en début de liste addLast(Object o) : ajoute un objet o en fin de liste clear() : vide la liste contains(Object o) : renvoie true si la liste contient l'objet o, false sinon. getFirst() et getLast() : renvoie le premier et le dernier élément de la liste sous forme d'Object. Ne pas oublier le cast. removeFirst() et removeLast() : retire le premier et le dernier élément de la liste. size() : renvoie la taille de la liste

Constructor Summary LinkedList()           Constructs an empty list. LinkedList(Collection<? extends E> c)            Constructs a list containing the elements of the specified collection, in the order they are returned by the collection's iterator.  Method Summary  void addFirst(E o)           Inserts the given element at the beginning of this list.  void addLast(E o)           Appends the given element to the end of this list.  E element()           Retrieves, but does not remove, the head (first element) of this list.  E getFirst()           Returns the first element in this list.  E getLast()           Returns the last element in this list.  Boolean offer(E o)           Adds the specified element as the tail (last element) of this list.  E peek()           Retrieves, but does not remove, the head (first element) of this list.  E poll()           Retrieves and removes the head (first element) of this list.  E remove()           Retrieves and removes the head (first element) of this list.  E removeFirst()           Removes and returns the first element from this list.  E removeLast()           Removes and returns the last element from this list.

Si vous devez parcourir la liste, il est préférable d’utiliser un itérateur que la position de l’élément courant. Exemple : List<Employe> paie = new LinkedList<Employe>(); … ListIterator<Employe> indiceI; //retourne un itérateur placé avant le premier élement. indiceI = paie.listIterator(); while(indiceI.hasNext()) indiceI.next().payer(); Est plus efficace que : List<Employe> paie = new Vector<Employe>(); for(int i=0 ; i<paie.size(); i++) paie.get(i).payer(); Car la méthode get() va parcourir tous les éléments précédents l’élément courant (ou tous les éléments suivants s’il est plus près de la fin).