LES COLLECTIONS
1. Présentation
La collection peut être assimilée à un tableau d’objets qui grandirait automatiquement pour accepter tout ce qu'on y place. Le nombre d'objets qu'on désire stocker dans une collection n'est donc pas nécessairement connu. Il suffit de créer un objet conteneur et de le laisser gérer ses éléments. Les langages orientés objet fournissent ces conteneurs. Java propose des classes conteneurs dans sa bibliothèque standard notamment la classe ArrayList qu’on utilise souvent pour gérer les collections.
Tous les conteneurs disposent de moyens pour stocker des objets et les récupérer.
Une collection est donc un espace de stockage où placer des objets, son implémentation réelle n'a pas grande importance.
Remarque : ArrayList figure dans le package java.util, il faut prévoir l’import java.util.* en début de programme.
2. La collection ArrayList : principes et exemple
L'utilisation d'une ArrayList est simple: il suffit de la créer, d'y ajouter des éléments avec la méthode add(), et d'y accéder ensuite grâce à la méthode get() en utilisant un index comme pour un tableau, mais sans les crochets. ArrayList propose aussi une méthode size() qui permet de savoir combien d'éléments ont été stockés.
La classe ArrayList hérite de la classe abstraite AbstractList et implémente plusieurs interfaces notamment l'interface List qui elle-même hérite de Collection. Les éléments d'un objet ArrayList peuvent être de n'importe quel type d’objet, la valeur null y est également tolérée.
Les collections contiennent des objets non typés, il faut donc obligatoirement faire un cast, lors de l’extraction, vers le type d’objet attendu.
Exemple :
Eleve e1 = new Eleve("toto", 10, 2) ;
ArrayList colEleve = new ArrayList(); // Collection colEleve
Boolean b = colEleve.add(e1); // ajout de e1 à la collection, c’est un objet de type
// Eleve stocké comme Object
Eleve e2; // déclaration d’une référence sur Eleve
int i = 0;
e2 = (Eleve)colEleve.get(i); // transtypage de l’objet de rang i en Eleve et
// référencement par e2
i = colEleve.size() ; // i contiendra le nombre d’objets de la collection
3. Présentation des principales méthodes de ArrayList
-déclaration par défaut : capacité initiale = 10
ArrayList colEleve = new ArrayList();
-déclaration avec indication de la capacité
ArrayList liste = new ArrayList(100); // initialisé avec une capacité initiale
-Ajout : la méthode add
Eleve e=new Eleve("titi", 5.5, 1.5) ;
Boolean b = colEleve.add(e); // ajout de l’élève e à la collection
// on peut également utiliser add comme une procédure
-La méthode contains() fournit un moyen de vérification de présence d'un objet au sein d'une collection ArrayList.
Boolean resultat = colEleve.contains(objet); // vérifie si la liste contient l'élément spécifié
-Pour récupérer un objet dans la collection : il faut utiliser la méthode get
e2 = (Eleve)colEleve.get(i);
L’objet de rang i est extrait de la collection, transtypé et référencé par e2.
-La suppression d'un ou plusieurs éléments d'une liste s'accomplit par remove().
colEleve.remove(i); // supprime l'objet à l'index spécifié
liste.removeRange(5, 8); // supprime les objets compris dans l'intervalle spécifié
liste.clear(); // supprime tous les éléments de la liste
-Les méthodes indexOf() et lastIndexOf() permettent de rechercher l'élément fourni, respectivement à partir du début et de la fin de la liste.(-1 si non trouvé)
int indprem = liste.indexOf(obj); // recherche la première occurrence de l'objet spécifié
int indder = liste.lastIndexOf(obj); // recherche la dernière occurrence de l'objet spécifié
Remarques :
. Des surcharges de ces méthodes existent ainsi que d'autres méthodes ; pour cela consulter la documentation java.
. Avec la version 1.5 du jdk, il y a un petit problème lors de la compilation avec certaines méthodes de ArrayList (notamment avec la méthode add), il suffit de compiler avec –Xlint (exemple : javac –Xlint Ensemble_élèves.java) ; cela produit un warning mais ce n’est pas bloquant.
4. Les itérateurs
Un itérateur sert à parcourir la collection autrement qu’en définissant un indice. Il est géré par le système via la classe Iterator.
Exemple sans itérateur :
Eleve e = new Eleve("toto", 10, 2) ;
ArrayList colEleve = new ArrayList(); // Collection colEleve
// ajout d'élèves
…
…
int i;
for (i=0; i<colEleve.size(); i++) // affichage des élèves
{
System.out.println("Elève n°" + (i+1));
(Eleve)(colEleve.get(i)).affich(); //on suppose l'existence d'une méthode affich()
// dans la classe Eleve
}
Exemple avec itérateur :
Eleve e = new Eleve(" toto", 10 ,2) ;
ArrayList colEleve = new ArrayList(); // Collection colEleve
// ajout d'élèves
…
…
Iterator jeuErgts = colEleve.iterator() ; //déclaration d’un itérateur i sur la collection
while (jeuErgts.hasNext()) // affichage des élèves
{
((Eleve)jeuErgts.next()).affich(); //on suppose l'existence d'une méthode affich()
//dans la classe Eleve
}
Attention !! hasnext() teste l’existence du suivant, next() accède au suivant.
5. Exemple d’utilisation d’une collection (sans itérateur)
Si l’on place la collection comme membre privé d’une classe, on ne peut évidemment pas l’utiliser directement à l’extérieur de la classe. Il faut donc implémenter des méthodes publiques qui serviront à traiter les données de la collection. Chaque méthode utilisera les méthodes fournies par la collection pour produire le résultat attendu.
Exemple :
import java.util.*;
class Ensemble_emp
{
private ArrayList colEmploye = new ArrayList(); //collection colEmploye
public int cardinal() //méthode qui retournera la taille
{
return colEmploye.size(); //utilise la méthode size()
}
public void vider() //vide le collection
{
colEmploye.clear(); //utilise clear()
}
public void ajouter(Employe e) //ajoute un employé
{
colEmploye.add(e); //utilise add()
}
public void afficher()
{
int i;
for(i=0;i<colEmploye.size();i++)
((Employe)colEmploye.get(i)).affich(); //utilise get()
}
}
6. Utilisation algorithmique
Les collections ont pris beaucoup d'importance dans les langages de programmation ; il est donc utile de voir leur utilisation en pseudo-code.
On ne peut pas considérer l'existence préalable d'une classe Collection si cela n'est pas précisé mais souvent une classe Collection comme celle qui suit est proposée dans l'énoncé du problème :
Classe Collection // classe générique = Arraylist
Fonction cardinal () : entier //renvoie le nombre d’éléments de la
//collection=size()
Fonction existe (entrée : unObjet : objet) : booléen //teste si un objet existe dans la
//collection=contains()
Fonction index (entrée : unObjet : objet) : entier //renvoie l’index d’un objet de la
//collection
Fonction extraireObjet (entrée : index : entier) : objet //accède à un objet contenu
//dans la collection=get(i)
Fonction ajouter (entrée : unObjet : objet) : entier //ajoute un objet à la
//collection et renvoie
//l’index alloué ~ add()
Procédure enlever (entrée : index : entier ) //supprime un objet de la
//collection=remove()
Procédure vider() //vide le contenu de la collection=clear()
…
Finclasse
Pour instancier une collection :
uneCollection : Collection de <classe> // La collection instanciée contiendra des objets de la classe <classe>
Pour parcourir par itération les éléments d'un objet Collection :
Pour chaque <objet> dans <collection> faire
// instructions avec <objet>
FinPour
Exemple :
Classe EnsembleEleve
Privé:
colEleve : Collection de Eleve
Public:
Fonction ajoutCol (Eleve e) : entier
Début
Retourner colEleve.ajouter (e)
Fin
Procédure affichCol()
Début
Pour i de 0 à colEleve.cardinal() - 1 //affichage des élèves
Afficher "Elève n° " + (i + 1)
colEleve.extraireObjet(i).affich()
FinPour
Fin
// Si on n’a pas besoin d’afficher l’indice, on utilisera plutôt un itérateur :
Procédure affichCol2()
Début
e : Eleve
Pour chaque e dans colEleve
e.affich()
FinPour
Fin
FinClasse
Remarques :
- La collection est privée, il est donc ici obligatoire d’écrire des méthodes pour l’utiliser. Ces méthodes utilisent celles de la classe technique Collection.
- En algorithmique, on ne fait pas figurer le transtypage.