LECON 207


Les collections d'objets
Voici une partie qui va sans doute plaire...
Ici nous allons voir qu'il est possible de stocker des données autrement qu'avec des tableaux !
Et je dirais même plus, ces fameux objets collections sont dynamiques... en gros, ils n'ont pas de taille à pré-définir. On ne peut donc pas dépasser leur capacité !
Je ne passerai pas en revue tous les types et tous les objets collection... J'ajouterai aussi qu'il s'agit d'une présentation succinte des collections d'objets. Je préfère vous prévenir à l'avance !


Je sens que vous êtes impatients. Allons-y, alors !

Sommaire du chapitre :

  • L'objet LinkedList
  • L'objet ArrayList
  • L'objet Hashtable
  • L'objet HashSet


L'objet LinkedList

Une liste chaînée est une liste dont chaque élément est relié au suivant par une référence à ce dernier, sa taille n'est pas fixe : on peut ajouter et enlever des éléments selon nos besoins.
Les LinkedList acceptent tout type d'objet.
Chaque élément contient une référence sur l'élément suivant sauf pour le dernier : son suivant est en fait null.
Cette classe se trouve dans le package java.util.

Voici un petit code pour appuyer mes dires :
Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
 
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
 
public class Test {
 
        public static void main(String[] args) {
         
                List l = new LinkedList();
                l.add(12);
                l.add("toto ! !");
                l.add(12.20f);
                
                
                for(int i = 0; i < l.size(); i++)
                        System.out.println("Élément à l'index " + i + " = " + l.get(i));
                
        }
}


Vous pourrez constater que tous les éléments s'affichent !
Maintenant, vous devez savoir autre chose sur ce genre d'objet. Ceux-ci implémentent l'interface Iterator. Ceci signifie que nous pouvons utiliser cette interface pour lister notre LinkedList.
Dans le code suivant, j'ai rajouté le parcours avec un itérateur :

Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
 
public class Test {
 
        public static void main(String[] args) {
         
                List l = new LinkedList();
                l.add(12);
                l.add("toto ! !");
                l.add(12.20f);
                
                
                for(int i = 0; i < l.size(); i++)
                        System.out.println("Élément à l'index " + i + " = " + l.get(i));
                
                
                System.out.println("\n \tParcours avec un itérateur ");
                System.out.println("-----------------------------------");
                ListIterator li = l.listIterator();
                
                while(li.hasNext())
                        System.out.println(li.next());
        }
}


Vous pouvez constater que les deux manières de procéder sont analogues !
Cependant, je dois vous dire quelques choses sur les listes chaînées. Vu que les éléments ont une référence à leur élément suivant, ce type de listes peut être particulièrement lourd lorsqu'elles deviennent volumineuses !
À utiliser avec précaution. Si vous voulez en savoir plus, c'est par là.
Nous allons voir un autre objet de la même famille : les ArrayList.

L'objet ArrayList

Voici un objet bien pratique.
Un ArrayList est donc un de ces objets qui n'ont pas de taille limite, et en plus, ils acceptent n'importe quel type de données ! null y compris !

Dans un ArrayList, nous pouvons mettre tout ce que nous voulons. Vous devez par contre importer la classe ArrayList. Elle se trouve dans le package java.util. Mais vous connaissez une bonne technique pour importer vos classes !

Pour preuve, voici un morceau de code qui le met en œuvre :

Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
 
import java.util.ArrayList;
 
public class Test {
 
        public static void main(String[] args) {
         
                ArrayList al = new ArrayList();
                al.add(12);
                al.add("Une chaîne de caractères !");
                al.add(12.20f);
                al.add('d');
                
                for(int i = 0; i < al.size(); i++)
                {
                        System.out.println("donnée à l'indice " + i + " = " + al.get(i));
                }               
        }
}


Si vous exécutez ce code, vous aurez :



Je pense que vous voyez déjà les avantages des ArrayList.
Vous devez savoir aussi qu'il existe tout un panel de méthodes dans cet objet :
  • add() : permet d'ajouter un élément.
  • get(int index) : retourne l'élément à l'index demandé.
  • remove(int index) : efface l'entrée à l'indice demandé.
  • isEmpty() : renvoie "vrai" si l'objet est vide.
  • removeAll(): efface tout le contenu de l'objet.
  • contains(Object element): retourne "vrai" si l'élément passé en paramètre est dans l'objet.
  • ...


Si vous voulez en savoir plus, c'est par là.

Un autre objet pratique, les Hashtable.

L'objet Hashtable

Table de hachage, si vous traduisez mot à mot...
Ce type d'objet rentre dans la catégorie des Map. Entendez par là qu'ils rangent leurs éléments avec un système "clé-valeur". La clé est unique, mais la valeur, elle, peut être associée à plusieurs clés !

On parcourt ces objets grâce aux clés qu'ils contiennent. Vu que notre mémoire peut être défaillante, il existe un moyen de parcours très simple. En utilisant la classe Enumeration. L'objet obtient tout le contenu de notre Hashtable et permet de le parcourir très simplement. Regardez, le code suivant insère les saisons avec des clés qui ne se suivent pas, et notre énumération récupère seulement les valeurs :

Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
 
import java.util.Enumeration;
import java.util.Hashtable;
 
public class Test {
 
        public static void main(String[] args) {
         
                Hashtable ht = new Hashtable();
                ht.put(1, "printemps");
                ht.put(10, "été");
                ht.put(12, "automne");
                ht.put(45, "hiver");
                
                Enumeration e = ht.elements();
                
                while(e.hasMoreElements())
                        System.out.println(e.nextElement());
                
        }
}


Vous constaterez que le code marche très bien et qu'il est très simple d'utilisation.
Cet objet nous offre lui aussi tout un panel de méthodes utiles :
  • isEmpty() : retourne "vrai" si l'objet est vide.
  • contains(Object value) : retourne "vrai" si la valeur est présente. Identique à containsValue(Object value).
  • containsKey(Object key) : retourne "vrai" si la clé passée en paramètre est présente.
  • put(Object key, Object value) : ajoute le couple key/value dans l'objet.
  • elements() : retoune une énumération des éléments de l'objet.
  • keys() : retourne la liste des clés sous forme d'énumération.
  • ...


Vous devez savoir qu'il existe un autre objet de type Map : il s'agit du HashMap ; son utilisation ne diffère que très peu du Hashtable. Je n'en parlerai donc pas...

Si vous voulez en savoir plus sur les Hashtable, c'est par là.

L'objet HashSet

Un Set est une collection qui n'accepte pas les doublons. Elle n'accepte qu'une seule fois la valeur null, car deux fois cette valeur est considérée comme un doublon.
On peut dire que cet objet n'a que des éléments différents en son sein !
Certains Set sont plus restrictifs que d'autres, n'acceptent pas null ou un certain type d'objet.
On peut parcourir ce type de collection avec un objet Iterator ou, cet objet peut retourner un tableau d'Object.
Voici un code simple :

Code : Java -  
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
import java.util.HashSet;
import java.util.Iterator;
 
public class Test {
 
        public static void main(String[] args) {
         
                HashSet hs = new HashSet();
                hs.add("toto");
                hs.add(12);
                hs.add('d');
                
                Iterator it = hs.iterator();
                while(it.hasNext())
                        System.out.println(it.next());
 
                System.out.println("\nParcours avec un tableau d'objet");
                System.out.println("-----------------------------------");
                
                Object[] obj = hs.toArray();
                for(Object o : obj)
                        System.out.println(o);
                
        }
}


Voici une liste des méthodes que l'on peut trouver dans cet objet :
  • add() : ajoute un élément.
  • contains(Object value) : retourne "vrai" si l'objet contient value.
  • isEmpty() : retourne "vrai" si l'objet est vide.
  • iterator(): renvoie un objet de type Iterator.
  • remove(Object o) : retire l'objet o de la collection.
  • toArray() : retourne un tableau d'Object.
  • ...


Pour en savoir plus sur les HashSet, c'est par là.

Voilà : nous avons vu quelque chose d'assez intéressant. Je ne pense pas qu'un QCM soit de mise pour cette partie... Profitez-en !
Allez ! Zou...

Voici encore un chapitre important !
Surtout prenez bien le temps de faire des tests, de voir comment se comporte chaque objet...

Le principal problème qui va se poser maintenant, c'est :
Quelle collection utiliser ?

Pour ceci, je ne peux pas vous aider... cela dépendra du type de besoin que vous aurez...
Personnellement, je me sers le plus souvent d'ArrayList et de Hashtable.

Dès que vous vous sentez prêts, en avant pour la généricité en Java.

// // 0 comments //

0 comments to "LECON 207"

Post a Comment

About This Blog

Aller au debut de la page