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.