Vous êtes sur la page 1sur 23

Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

CHAPITRE : 1
Les collections
(Listes, ensembles, tables associatives)
PROGRAMMATION OBJET AVANCEE

1
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

1. Introduction
- Les collections sont des objets permettant de gérer des ensembles d'objets avec éventuellement la
possibilité de gérer les doublons, les ordres de tri, etc.
- Elles sont utilisées pour stocker, retrouver et manipuler des données, ainsi que pour transmettre des
données d’une méthode à une autre.
- Les collections fournissent en plus une séparation entre leur implémentation effective et leur usage,
permettant ainsi une meilleure réutilisabilité. Pour cela,on utilise l'héritage et les interfaces.

Package qui contient les collections : - java.util.*

Figure1 : Hiérarchie des interfaces et des classes de collection

Collection : interface qui est implémentée par la plupart des objets qui gèrent des collections.
Set : interface pour des objets qui n'autorisent pas la gestion des doublons dans l'ensemble
SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble
List : interface pour des objets qui autorisent la gestion des doublons et un accès direct a un élément
Queue : interface qui étend l'interface Collection pour une file de données type FIFO
Map : interface qui définit des méthodes pour des objets qui gérent des collections sous la forme
clé/valeur. Attention, ce n’est pas un sous-type de collection !
SortedMap : interface qui étend l'interface Map et permet d'ordonner l'ensemble. Un tableau associatif
avec une relation d'ordre sur les clés.
2
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

http://docs.oracle.com/javase/7/docs/api/java/util/Collection.html Documentation
officielle java 7 et collection
Type Nom Interface Classe Description

Les listes Vector X représente un tableau dynamique dont la taille peut varier.
ArrayList X représente un tableau dynamique dont la taille peut varier.
LinkedList X représente une liste doublement chaînée.
Ensembles HashSet X représente un ensemble sans ordre de tri particulier.
LinkedHashSet X comme HashSet en conservant l'ordre d'insertion dans une
liste doublement chaînée.
SortedSet X définit une collection de type ensemble triée.
NavigableSet X étend l’interface SortedSet par des méthodes de navigation
TreeSet X représente un arbre qui représente un ensemble trié
d'éléments
Les Maps Hashtable X représente un tableau associatif dont les clés ne peuvent être
nulles.
HashMap X représente un tableau associatif dont une clé et des valeurs
peuvent être nulles.
LinkedHashMap X constitue à la fois une table de hachage Map et une liste
chaînée avec un ordre d'itération prévisible.
SortedMap X définit une collection de type Map triée sur la clé
NavigableMap X étend l’interface SortedMap par des méthodes de navigation
TreeMap X représente un tableau associatif dont les clés sont classées en
ordre croissant.
Files PriorityQueue X représente un mécanisme de pile de type FIFO (First in First
out).

3. La généricité Collection<E> et types paramètrés


Depuis le JDK 5.0, les collections sont manipulées par le biais de classes génériques implémentant
l’interface Collection<E>, E représentant le type des éléments de la collection. Tous les éléments
d’une même collection sont donc de même type E (ou, à la rigueur, d’un type dérivé de E). Ainsi, à
une liste chaînée ArrayList<String>, on ne pourra pas ajouter des éléments de type Integer ou Point.
Avant le JDK 5.0, les collections (qui implémentaient alors l’interface Collection) pouvaient
contenir des éléments d’un type objet quelconque. Par exemple, on pouvait théoriquement
créer une liste chaînée (ArrayList) contenant à la fois des éléments de type Integer, String,
Point... En pratique, ce genre de collection hétérogène était peu employé.
Remarque
Sauf exceptions :
- Toutes les collections acceptent null comme un élément valide (mais ce n'est pas une bonne idée !)
- Toutes les collections testent si un objet existe ou non par rapport à la méthode equals() de l'objet.
Les types génériques permettent de spécifier le type d'objets que l'on va placer dans une collection
d'objets (List, Vector,...)

Avantages:

* meilleure lisibilité: on connaît à la lecture du programme quel type d'objets seront placés dans la
collection.

* La vérification peut être faite a la compilation.

* Le cast pour récupérer un objet de la collection est devenu implicite (sans cette fonctionnalité, il
fallait faire un cast explicite.

3
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

4. Les Collections

4.1.Interface Collection
– Cette interface définit des méthodes pour des objets qui gèrent des éléments d'une façon assez générale. Elle
est la super interface de plusieurs interfaces du framework.
– Plusieurs classes qui gèrent une collection implémentent une interface qui hérite de l'interface Collection.
– Cette interface est une des deux racines de l'arborescence des collections.
– L'interface Collection possède cinq sous-interfaces List, Set, SortedSet, NavigableSet et Queue.
– Les implémentations de l'interface Collection sont AbstractCollection, AbstractList, AbstractSet, ArrayList,
HashSet, LinkedHashSet, LinkedList, TreeSet et Vector.
– Cette interface définit plusieurs méthodes :

Type Méthode Rôle


boolean add(Object o) Ajouter un objet à la collection.
boolean remove(Object o) Retirer un objet de la collection.
boolean contains(Object o) Tester si la collection contient l'objet indiqué.
boolean addAll(Collection c) Ajouter tous les objets d'une autre collection à celle-ci.
boolean removeAll(Collection c) Retirer tous les objets d'une autre collection de celle-ci.
boolean retainAll(Collection c) Retirer tous les objets qui ne sont pas dans la collection
spécifiée de celle-ci. À la fin les deux collections contiennent les
mêmes objets.
boolean containsAll(Collection c) Tester si la collection contient tous les objets de la collection
indiquée.
void clear() Vider la collection.
boolean isEmpty() Tester si la collection est vide.
Iterator iterator() Retourne un itérateur permettant de faire une boucle sur tous
les objets contenus dans la collection.
int size() Retourne le nombre d'objets de la collection.
Object[] toArray() Convertit la collection en tableau d'objets.

Exemple 1. Création d'une collection de String

Notons que l'on n'a pas à se soucier des problèmes de dépassement de capacité. La capacité d'une
collection est censée être infinie (enfin presque...).

import java.util.ArrayList;

public class Main {

public static void main(String[] args) {

//nous créons une collection basique


Collection<String> list = new ArrayList<String>();

// ajout d'éléments à cette collection

list.add("un");
list.add("deux");
list.add("trois");
list.add("quatre");
list.add("cinq");
list.add("six");
list.add("sept");
}
}

4
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

4.2. Test d'appartenance d'un objet à une collection

L'interface Collection expose une méthode contains(T) qui nous permet de tester si un objet précis
appartient à une collection.

Exemple 2. Test d'appartenance d'un objet à une collection

// test d'appartenance de "deux"


boolean b1 = list.contains("deux") ;
System.out.println(b1) ; // affiche true

// test d'appartenance de "DEUX"


boolean b2 = list.contains("DEUX") ;
System.out.println(b2) ; // affiche false

Dans le cas de ArrayList cette méthode appelle la méthode equals() de l'objet passé en paramètre, pour
tous les objets de la collection.

Remarque

pour des éléments de type String, File ou d’une classe enveloppe(Byte, Long, Integer, Short, Double, Float..),
les chosesseront naturelles puisque leur méthode equals se base réellement sur la valeur des objets. Enrevanche,
pour les autres, il faut se souvenir que, par défaut, leur méthode equals est cellehéritée de la classe Object. Elle
se base simplement sur les références : deux objets différentsapparaîtront toujours comme non égaux (même
s’ils contiennent exactement les mêmesvaleurs). Pour obtenir un comportement plus satisfaisant, il faudra alors
redéfinir la méthode equals de façon appropriée, ce qui ne sera possible que dans des classes qu’on définit soi
même.

Exemple 3

Solution

@Override

public boolean equals(Object obj) {

if(this==obj)
return true;

if(obj==null || !this.getClass().equals(obj.getClass()))

return false;

Point point=(Point)obj;

return (this.getX()==point.getX()&& (this.getX()==point.getX());

5
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

4.3. Parcourir les éléments d'une collection

Il existe deux façons de faire pour parcourir les éléments d'une collection.

4.3.1. Les itérateurs

première consiste à créer un un objet de l'interface Iterator sur la collection, et à l'utiliser.

Voici les méthodes présentes dans cette interface :

boolean hasNext() retourne true si l'itérateur a encore des éléments.


Object next() retourne le prochain élément de l'itérateur.
void remove() supprime de la collection sous-jacente le dernier élément retourné par l'itérateur.

Le fonctionnement de l'itérateur consiste dans un premier temps, à récupérer un objet Iterator par
l'intermédiaire de la méthode iterator() disponible dans toutes les classes implémentant les interfaces List et
Set, telles que AbstractList, ArrayList, LinkedList, Vector, AbstractSet, HashSet, LinkedHashSet et TreeSet.
Puis à l'aide d'une boucle, dont la condition d'arrêt est une expression faisant appel à la méthode hasNext()
afin de vérifier si l'itérateur possède encore des éléments, récupérer dans un objet, les éléments de l'itérateur
en utilisant la méthode next().

Exemple

import java.util.ArrayList;
import java.util.Iterator;

public class Main {

public static void main(String[] args) {


//nous créons une collection basique
Collection<String> list = new ArrayList<String>();
list.add("un");
list.add("deux");
list.add("trois");
list.add("quatre");
list.add("cinq");

//Un petit compteur pour récupérer les tours de boucle


int nbTourDeBoucle = 0;
int nbTourDeBoucle2 = 0;

//Nous récupérons notre itérateur


Iterator it = list.iterator();

//tant qu'il y a des éléments à parcourir


while(it.hasNext()){

nbTourDeBoucle++;
//nous récupérons l’élément courant
String str = (String)it.next();
//si nous sommes sur l'élément 4, nous le retirons de la collection
if(str.equals("quatre"))
it.remove();
}

//nous reparcourons un nouvel itérateur


//pour nous assurer que tout a fonctionné
it = list.iterator();

while(it.hasNext()){

6
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

nbTourDeBoucle2++;
System.out.println(it.next());
}

System.out.println("Nombre de tours de boucle N°1 : " + nbTourDeBoucle);


System.out.println("Nombre de tours de boucle N°2 : " + nbTourDeBoucle2);

}
}

Remarque

nous pouvons aussi récupérer un itérateur générique. Je ne l'ai pas fait ici mais vous auriez pu faire ceci
: Iterator<String> it = list.iterator(); ce qui évite d'avoir à caster les résultats retournés par la
méthode next().

L'opération next() est sécurisée et lève une exception dans le cas où on dépasse la fin de la
collection (c-a-d si hasNext() renvoie false)

4.3.2 Parcourir les éléments d'une collection avec un for each

Cette seconde syntaxe est beaucoup plus légère et lisible que la première. Elle est largement suffisante
lorsque l'on veut juste parcourir ses éléments.

// Parcours d'une collection


Collection<ObjetX> collection = ......;

for(ObjetX objetX : collection){


……………………………………………
}

5.Listes (List) : java.util.List<E>

– Cette interface est implémentée par les classes ArrayList, LinkedList et Vector.
et garantit que ces classes implémenteront l'ensemble des méthodes. Elle dérive de l'interface Collection.
Les éléments sont indexés (i.e. numérotés de la même façon qu'un tableau est indicé).

7
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

5.1. Les implémentations de l’interface List


5.1.1 ArrayList

– ArrayList<E> implante l'interface List. Elle est utiliser pour les tableaux à taille variable.
– Elle hérite de la classe AbstractList donc elle implémente l'interface List.
– Elle définit plusieurs méthodes dont les principales sont :
boolean add(Object) ajoute un élément à la fin du tableau
boolean addAll(Collection) ajoute tous les éléments de la collection fournie en paramètre à la fin du
tableau
boolean addAll(int, Collection) ajoute tous les éléments de la collection fournie en paramètre dans la
collection à partir de la position précisée
void clear() supprime tous les éléments du tableau
Object get(index) renvoie l'élément du tableau dont la position est précisée
int indexOf(Object) renvoie la position de la première occurrence de l'élément fourni en
paramètre
boolean isEmpty() indique si le tableau est vide
int lastIndexOf(Object) renvoie la position de la dernière occurrence de l'élément fourni en
paramètre
Object remove(int) supprime dans le tableau l'élément fourni en paramètre
void removeRange(int,int) supprime tous les éléments du tableau de la première position fourni
incluse jusqu'à la dernière position fournie exclue
Object set(int, Object) remplace l'élément à la position indiquée par celui fourni en paramètre
int size() Renvoie la taille de la liste

Exemple:

import java.util.*;
class Test1 {
public static void main(String args[]) {
ArrayList<String> semaine = new ArrayList<String> ();
semaine.add(new String("lundi") ;
semaine.add(new String("mardi") ;
semaine.add(new String("mercredi") ;
System.out.println ("Nombre d'éléments : " + l.size());
}}

5.1.2. La classe java.util.Vector<E>

– La classe Vector permet de créer une collection d'objets qui fonctionne de la même manière qu'un
tableau, à l'exception que sa capacité peut varier en fonction des besoins.
– Une allocation de mémoire dynamique est utilisée par les objets Vector, si bien qu'il est possible
d'ajouter, de supprimer aisément leurs éléments, soit de faire varier leur taille dynamiquement.
– De cette manière, un vecteur peut stocker un nombre quelconque d'objets de type Object, soit n'importe
quel genre d'objets (String, Integer, URL, Date, etc.).
– Par contre, un vecteur n'accepte pas les valeurs de types primitifs qui doivent être converties en objet.
– Un vecteur comporte quatre constructeurs permettant d'initialiser les instances de cette classe.
– Voyons les différentes manières de déclarer un nouveau vecteur :

8
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

Vector<T> vecteur = new Vector<T>(); On construit un Vecteur vide de taille 10 et d'incrément 1


(chaque élément de type T).
l'incrément est l'augmentation de la taille du vecteur une
fois plein
Vector<T> vecteur = new Vector<T>( int On construit un Vecteur en initialisant sa taille à «
initialcapacity); initialcapacity». Dans ce cas, la valeur contenue par chacun
des éléments est nulle. Cependant, cette initialisation peut
poser des problèmes de gestion d'espace mémoire, car un
vecteur initialisé à n éléments voit sa capacité doublée
lorsqu'un dépassement de sa capacité initiale intervient.
(chaque élément de type T)

Vector <T> vecteur = new Vector<T>(int Ici, on initialise le vecteur à une certaine taille tout en
initCapacity, int capcIncr); définissant un pas d'incrémentation de sa capacité suite à
un dépassement, palliant ainsi à la contrainte du
constructeur précédent.

Vector <T> vecteur = new Cette dernière solution permet de construire un vecteur à
Vector<T>(collection<T>); partir d'une collection passée en argument. Cette collection
doit implémenter l'interface Collection, à l'image de
ArrayList, HashSet, LinkedHashSet, LinkedList, TreeSet et
même Vector.

– Cette classe définit plusieurs méthodes :

void addElement(Object obj) ajoute l'élément obj au vecteur


Object elementAt(int index) renvoie l'objet d'indice index.
Object firstElement() renvoie le premier élément du vecteur.
void insertElementAt(Object obj, int index) insère l'objet obj de façon qu'il occupe l'indice index, les
objets situés à la suite étant décalés.
boolean isEmpty() renvoie true si le vecteur est vide, sinon false.
Object lastElement() renvoie le dernier élément du vecteur.
void removeAllElement() supprime tous les éléments du vecteur et remet à 0 le size
du vecteur.
boolean removeElement(Object obj) supprime la première occurrence de l'objet obj et avance
d'un indice tous les éléments situés derrière. renvoie true si
l'objet existe, sinon false.
void removeElementAt(int index) Supprime l'élément d'indice index et avance d'un indice
tous les éléments situés derrière.
void setElementAt(Object obj, int index) remplace l'élément d'indice index par l'objet obj.
int size() donne le nombre des éléments du vecteur

Void setSize(int ns) Changer la taille effective du vecteur

Int capacity() Retourne la capacité du vecteur

Exemple1:
import java.util.*;
class Test1 {
public static void main(String args[]) {
Vector<Integer> vecteur = new Vector<Integer>(10);
// Affiche 10
System.out.println ("Taille du vecteur : " + vecteur.capacity());
for(int i = 0; i < vecteur.capacity(); i++) vecteur.add(i, new Integer(1900 + i));
vecteur.add(vecteur.size(), new Integer(1900 + 11));
// Affiche 20
System.out.println ("Nombre d'éléments : " + vecteur.size());
System.out.println ("Taille du vecteur : " + vecteur.capacity()); }}
Exemple2:
public class Test2{
public static void main(String[] args) {
Vector<String> vecteur = new Vector<String>();
vecteur.add("lundi");
vecteur.add("mardi");
vecteur.add("mercredi");
vecteur.add("jeudi");
vecteur.add("Vendredi");
Vector<String> v1 = new Vector<String>(vecteur);
Vector<String> v2 = new Vector<String> (vecteur);
v1.removeAllElements();
v2.clear();
System.out.println ("La taille du vecteur (1, 2) : " + v1.size() + ", " + v1.size() );
System.out.println ("La capacité du vecteur (1, 2) : " + v1.capacity() + ", " + v1.capacity()); }}

9
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

6.Les files
Une queue n’est rien d’autre qu’une structure de données de type FIFO (First In, First Out).

L’interface Queue
-Introduit une nouvelle interface pour les collections : java.util.Queue.
-L’interface Queue étend l'interface Collection pour définir une collection ordonnée d'éléments ede manière à
les traiter dans une file d'attente FIFO
-L'élément qui est insérée d'abord sera également retiré en premier.
-Avec les opérations basiques de collection, l’interface Queue offre d'autres opérations telles que l'insertion,
suppression,etd'inspection.
-Les méthodes de cette interface sont comme suit :
peek( ) Retourne un élément, mais si la file d'attente est vide, il renvoie null
poll( ) Supprime un élément, mais retour null si la file d'attente est vide
offer(E element) insère un élément si possible, sinon retourne false
element() Retourne un élément

Implémentation de l’interface Queue


Nous distinguons deux types de classes qui implémentent la classe Queue la classe LinkedList (cette classe
a été déjà expliqué dans le paragraphe 3.3) et la classe PriorityQueue (ordonnancement naturel des
éléments).

PriorityQueue
-Cette nouvelle interface comporte un certain nombre de signatures supplémentaires pour ajouter,
supprimer des éléments, et parcourir la collection.
-L’ordre de PriorityQueue est basé sur l'ordre naturel des éléments, c'est à dire par la valeur renvoyé par
la méthode compareTo() (il faut alors que l'objet implémente Comparable).
-Pour les String il s'agit donc de l'ordre "alphabétique".
Exemple:
PriorityQueue<String> queue = new PriorityQueue<String>();
queue.offer("CCC-1");
queue.offer("BBB");
queue.offer("AAA");
queue.offer("CCC-2");
out.println("1. " + queue.poll()); // removes
out.println("2. " + queue.poll()); // removes
out.println("3. " + queue.peek());
out.println("4. " + queue.peek());
out.println("5. " + queue.remove()); // removes
out.println("6. " + queue.remove()); // removes
out.println("7. " + queue.peek());
out.println("8. " + queue.element()); // Throws NoSuchElementException !
Le output est:
1. AAA
2. BBB
3. CCC-1
4. CCC-1
5. CCC-1
6. CCC-2
7. null
Exception in thread "main" java.util.NoSuchElementException
at java.util.AbstractQueue.element(Unknown Source)
at regex.Replacement.main(Replacement.java:28)

7 .Les ensembles(SET) :
Un ensemble (Set) est une collection qui n'autorise pas l'insertion de doublons.

7.1 Interface Set


– L'interface Set représente une collection ne contenant aucun élément en double. Autrement
dit, les ensembles ne doivent contenir que des éléments uniques.
– La méthode equals() appliquée entre chaque objet d'une implémentation de l'interface Set, doit
retourner obligatoirement false.
– Les collections Set peuvent accepter des objets de n'importe quel type, ainsi qu'au plus un et un seul
élement null.
– L'interface Set est implémentée par les classes HashSet et AbstractSet.
– De même, elle est étendue par l'interface SortedSet qui permet un tri sur un ensemble. L'autre classe
TreeSet n'implémente pas directement l'interface Set puisqu'elle s'appuie sur l'interface SortedSet. Cette

10
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

classe définit les méthodes d'une collection qui n'accepte pas de doublons dans ces éléments. Elle hérite
de l'interface Collection mais elle ne définie pas de nouvelle méthode.
– Pour déterminer si un élément est déjà inséré dans la collection, la méthode equals() est utilisée.
– Le framework propose deux classes qui implémentent l'interface Set : TreeSet et HashSet

– Le choix entre ces deux objets est lié à la nécessité de trier les éléments :
o les éléments d'un objet HashSet ne sont pas triés : l'insertion d'un nouvel élément est rapide
o les éléments d'un objet TreeSet sont triés : l'insertion d'un nouvel élément est plus long

7.2 Interface SortedSet


– Cette interface définit une collection de type ensemble triée. Elle hérite de l'interface Set.
– Le tri de l'ensemble peut être assuré par deux façons :
o les éléments contenus dans l'ensemble implémentent l'interface Comparable pour définir
leur ordre naturel
o il faut fournir au constructeur de l'ensemble un objet Comparator qui définit l'ordre de tri à
utiliser
– Elle définit plusieurs méthodes pour tirer parti de cet ordre :

Comparator comparator() renvoie l'objet qui permet de trier l'ensemble


Object first() renvoie le premier élément de l'ensemble
SortedSet headSet(Object) renvoie un sous ensemble contenant tous les éléments inférieurs à celui
fourni en paramètre
Object last() renvoie le dernier élément de l'ensemble
SortedSet subSet(Object, Object) renvoie un sous ensemble contenant les éléments compris entre le
premier paramètre inclus et le second exclus
SortedSet tailSet(Object) renvoie un sous ensemble contenant tous les éléments supérieurs ou
égaux à celui fourni en paramètre

7.3 La classe HashSet


– Cette classe est un ensemble sans ordre de tri particulier.
– Les éléments sont stockés dans une table de hashage : cette table possède une capacité

Constructeurs :

Crée une HashSet de capacité initiale16 et de


HashSet()
loadFactor 0.75.
Crée une HashSet de capacité initialecapaciteInitiale
HashSet( int capaciteInitiale)
et de loadFactor 0.75.
Crée une HashSet de capacité initiale capaciteInitiale
HashSet( int capaciteInitiale, float loadFactor)
et et de loadFactor loadFactor.
Crée une HashSet contenant tous les élément de
HashSet(Collection<? extends E> c)
la Collection c.

Méthodes :

void clear() Supprime tous les élément du Set.


Ajoute o dans le Set et retourne true si o a
boolean add(E o) été effectivement ajouté et false sinon (o était déjà
présent dans le Set)
boolean contains(Object o) Retourne true si l'objet o est dans le Set et false sinon.

boolean isEmpty() Retourne true si le Set est vide et false sinon.


Enlève du Set l'objet o et retourne true, retourne
boolean remove(Object o)
false si o n'est pas dans le Set.

11
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

int size() Retourne le nombre d'éléments du Set.


Iterator<E> iterator() Retourne un itérateur sur les éléments du Set.

Exemple1
import java.util.*;
public class TestHashSet {
public static void main(String args[]) {
HashSet <String> set = new HashSet<String> ();
set.add("CCCCC"); set.add("BBBBB"); set.add("DDDDD");set.add("BBBBB"); set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {System.out.println(iterator.next());}}}
Résultat:
AAAAA
DDDDD
BBBBB
CCCCC
Exemple2
public class CollectionSet {
public static void main(String[] args) {
String[] joursSemaine={"lundi","mardi", »mercredi","jeudi", "vendredi", "samedi", "dimanche"};
Set <String>ensemble = new HashSet<String>();
for(int i = 0; i < joursSemaine.length; i++){ ensemble.add(joursSemaine[i]); }
System.out.println("Taille de l'ensemble : " + ensemble.size());
Iterator<String> valeurs = ensemble.iterator();
while(valeurs.hasNext()){ System.out.println(valeurs.next());
valeurs.remove();}
System.out.println("Taille de l'ensemble : " + ensemble.size()); }}

Exemple2:
import java.util.*;
public class CollectionTest {
public static void main(String [] args) {
System.out.println( "Collection Example!\n" );
int size;
// Create a collection
HashSet <String>collection = new HashSet <String>();
String str1 = "Yellow", str2 = "White", str3 = "Green", str4 = "Blue";
Iterator iterator;
//Adding data in the collection
collection.add(str1); collection.add(str2); collection.add(str3); collecti
on.add(str4);
System.out.print("Collection data: ");
//Create a iterator
iterator = collection.iterator();
while (iterator.hasNext()){System.out.print(iterator.next() + " ");}
System.out.println();
// Get size of a collection
size = collection.size();
if (collection.isEmpty()){ System.out.println("Collection is empty");}
else{System.out.println( "Collection size: " + size);}
System.out.println();
// Remove specific data
collection.remove(str2);
System.out.println("After removing [" + str2 + "]\n");
System.out.print("Now collection data: ");
iterator = collection.iterator();
while (iterator.hasNext()){System.out.print(iterator.next() + " ");}
System.out.println();
size = collection.size();
System.out.println("Collection size: " + size + "\n");
//Collection empty
collection.clear();
size = collection.size();
if (collection.isEmpty()){System.out.println("Collection is empty");}
else{System.out.println( "Collection size: " + size);}
}}

12
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

L’ output est :
Collection Example!
Collection data: Blue White Green Yellow
Collection size: 4
After removing [White]
Now collection data: Blue Green Yellow
Collection size: 3
Collection is empty

7.4 La classe TreeSet


- Cette classe est un arbre qui représente un ensemble trié d'éléments.
- Cette classe permet d'insérer des éléments dans n'importe quel ordre et de restituer ces éléments dans
un ordre précis lors de son parcours.
- L'implémentation de cette classe insère un nouvel élément dans l'arbre à la position correspondant à
celle déterminée par l'ordre de tri. L'insertion d'un nouvel élément dans un objet de la classe TreeSet est
donc plus lent mais le tri est directement effectué.
- L'ordre utilisé est celui indiqué par les objets insérés si ils implémentent l'interface Comparable pour un
ordre de tri naturel ou fournir un objet de type Comparator au constructeur de l'objet TreeSet pour
définir l'ordre de tri.

Exemple1
import java.util.*;
public class TestTreeSet {
public static void main(String args[]) {
TreeSet <String>set = new TreeSet<String>();
set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {System.out.println(iterator.next());}
}}
Résulat :
AAAAA
BBBBB
CCCCC
DDDDD

Exemple 2:
import java.util.*;
public class SetDemo {
public static void main(String args[]) {
int count[]={34, 22,10,60,30,22};
Set<Integer> set = new HashSet<Integer>();
try{for(int i=0; i<5; i++){set.add(count[i]);}
System.out.println(set);
TreeSet sortedSet=new TreeSet<Integer>(set);
System.out.println("The sorted list is:");
System.out.println(sortedSet);
System.out.println("The First element of the set is: "+
(Integer)sortedSet.first());
System.out.println("The last element of the set is: "+
(Integer)sortedSet.last());
}catch(Exception e){}
}}
Le output du programme :
[34, 22, 10, 30, 60]
The sorted list is:
[10, 22, 30, 34, 60]
The First element of the set is: 10
The last element of the set is: 60

13
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

8. Le tri des collections


- Les structures ordonnées classent leurs éléments de deux façons :
o selon leur ordre naturel, c’est-à-dire en utilisant le résultat de leur méthode
compareTo(),
o ou à l'aide d'un comparateur, c'est-à-dire d'un objet implémentant l'interface
Comparator.
- L'utilité des comparateurs vient de ce que l'ordre naturel ne convient pas toujours à
certaines structures. Par exemple, certains objets peuvent disposer d'une méthode
compareTo() donnant un ordre partiel alors qu'une structure peut nécessiter un ordre total.
- L'ordre de tri est défini grâce à deux interfaces :
o Comparable
o Comparator
- Les tables ordonnées SortedMap et les ensembles ordonnés (SortedSet) exploitent les comparateurs
pour trier leurs éléments.

8.1. L'interface Comparable


- Tous les objets qui doivent définir un ordre naturel utilisé par le tri d'une collection avec cet ordre
doivent implémenter cette interface.
- Cette interface ne définit qu'une seule méthode : int compareTo(T o).
- Cette méthode doit renvoyer :
o une valeur entière négative si l'objet courant est inférieur à l'objet fourni
o une valeur entière positive si l'objet courant est supérieur à l'objet fourni
o une valeur nulle si l'objet courant est égal à l'objet fourni
- Les classes wrappers (Byte, Long, Integer, Short, Double, Float, BigInteger, BigDecimal ) :
Tri du plus petit au plus grand. String: Tri par ordre alphabétique , Date: Tri chronologique etc..
implémentent cette interface.
-
package java.lang;
public interface Comparable<T> {
/*** Compares this object with the specified object for order.Returns a
* negative integer, zero, or a positive integer as this object is less
* than, equal to, or greater than the specified object.*/
public int compareTo(T o);
}

Exemple 1
vous devez savoir que certaines implémentations de l'interface Collection savent
naturellement trier leur contenu, c'est le cas des objets TreeSet. Voyez plutôt :
Set<String> tree = new TreeSet();
tree.add("André");
tree.add("Gislain");
tree.add("Matthieu");
tree.add("Cyrille");
tree.add("Zoé");
tree.add("Thierry");

Iterator<String> it = tree.iterator();
while(it.hasNext())
System.out.println(it.next());

Mais vous avez aussi la possibilité d'utiliser la méthode sort() de l'objet Collections, ainsi :
List<Double> list = new ArrayList<Double>();
list.add(-0.25d);
list.add(12.52d);
list.add(56.25d);
list.add(-45.12d);
list.add(-100.11d);
list.add(0.005d);
Collections.sort(list);
Iterator<Double> it = list.iterator();
while(it.hasNext())
System.out.println(it.next());

14
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

Vous pouvez donc trier des collections en utilisant ces objets selon leurs règles de tri prédéfinies ci-dessus… mais
vous pouvez également définir vos propres règles de tri en utilisant des objets perso qui implémentent
l'interface Comparable.

Voici la classe que nous allons utiliser pour comprendre tout ceci :
public class CD {
private String auteur, titre;
private double prix;
public CD(String auteur, String titre, double prix) {
this.auteur = auteur;
this.titre = titre;
this.prix = prix;
}

public String toString() {


return "CD [auteur=" + auteur + ", titre=" + titre + ", prix=" + prix
+ "]";
}

public String getAuteur() {


return auteur;
}

public String getTitre() {


return titre;
}

public double getPrix() {


return prix;
}
}
C'est une classe toute simple et nous allons voir si nous arrivons à la trier :
import java.util.ArrayList;
public class Main4 {

public static void main(String[] args) {


List<CD> list = new ArrayList<CD>();
list.add(new CD("Les arcandiers", "7€", 7d));
list.add(new CD("Frank Zappa", "Tinseltown rebellion", 10.25d));
list.add(new CD("Frank Zappa", "Bongo Fury", 10.25d));
list.add(new CD("King Crimson", "red", 15.30d));
list.add(new CD("Joe Zawinul", "World tour", 12.15d));

System.out.println("Avant le tri : ");


Iterator<CD> it = list.iterator();
while(it.hasNext())
System.out.println(it.next());

Collections.sort(list);

System.out.println("Après le tri : ");


it = list.iterator();
while(it.hasNext())
System.out.println(it.next());

}
}

Sans exécuter ce code, vous pouvez voir qu'Eclipse n'aime pas du tout la ligne suivante
: Collections.sort(list);
Voici ce qu'il nous dit :

15
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

Nous allons donc maintenant implémenter notre interface dans notre classe CD. Voici le
code complet de cette classe :
public class CD implements Comparable{
private String auteur, titre;
private double prix;
public CD(String auteur, String titre, double prix) {
this.auteur = auteur;
this.titre = titre;
this.prix = prix;
}

public String toString() {


return "CD [auteur=" + auteur + ", titre=" + titre + ", prix=" + prix
+ "]";
}

@Override
public int compareTo(Object o) {
if(o.getClass().equals(CD.class)){
//Nous allons trier sur le nom d'artiste
CD cd = (CD)o;
return this.auteur.compareTo(cd.getAuteur());
}
return -1;
}

public String getAuteur() {


return auteur;
}

public String getTitre() {


return titre;
}

public double getPrix() {


return prix;
}
}

Et voilà ! Le tour est joué !


Ici, nous n'avons défini qu'une façon très simple de comparer nos objets. Vous aurez
remarqué que, pour un même auteur, nous pouvons avoir plusieurs albums... Pour arranger
cela, nous n’avons qu'à gérer ce cas dans notre méthode compareTo(), comme ceci :

16
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)
public int compareTo(Object o) {
if(o.getClass().equals(CD.class)){
//Nous allons trier sur le nom d'artiste
CD cd = (CD)o;
//Si les deux CD ont le même auteur, on trie sur le nom de l'album
if(this.auteur.compareTo(cd.getAuteur()) == 0)
return this.titre.compareTo(cd.getTitre());
return this.auteur.compareTo(cd.getAuteur());
}
return -1;
}

8.2.Une nouvelle façon de trier : l'interface Comparator<T>


Précédemment, nous avons vu comment rendre un objet comparable à un autre afin de pouvoir trier nos collections, de
type List. Mais maintenant, si nous souhaitons de temps en temps trier nos CD non plus en fonction de leur auteur et leur

nom mais en fonction de leur prix, c'est là que l'interface Comparator<T> entre en jeu !

En fait, il existe une autre méthode sort() dans la classe Collections qui, elle, prend une collection et un objet de

type Comparator<T> en paramètre.

Que contient cette interface ?


Elle contient une méthode equals(Object o) et une méthode compare(T el1, T el2). C'est cette dernière qui

va nous intéresser ici. Elle fonctionne de la même manière que sa petite cousine compareTo() dans le sens où elle

renvoie un entier négatif, positif ou égal à 0 dans les différents cas, comme vu précédemment.

Ce que je vous propose, c'est de voir comment trier notre liste de CD par prix, tout en conservant la
méthode compareTo() dans la classe CD. Voici le code qui permet de faire cela :

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class Main5 {

public static void main(String[] args) {


List<CD> list = new ArrayList<CD>();
list.add(new CD("Les arcandiers", "7€", 7d));
list.add(new CD("Frank Zappa", "Tinseltown rebellion", 10.25d));
list.add(new CD("Frank Zappa", "Bongo Fury", 10.25d));
list.add(new CD("King Crimson", "red", 15.30d));
list.add(new CD("Joe Zawinul", "World tour", 12.15d));

System.out.println("Avant le tri : ");


Iterator<CD> it = list.iterator();
while(it.hasNext())
System.out.println(it.next());

Collections.sort(list);

System.out.println("Après le tri : ");


it = list.iterator();
while(it.hasNext())
System.out.println(it.next());

System.out.println("Après le tri avec notre comparateur");


//nous créons une classe anonyme ici, mais rien ne vous empêche d'en créer une dans un fichier séparé
Collections.sort(list, new Comparator<CD>(){
public int compare(CD cd1, CD cd2) {
Double prix1 = (Double)cd1.getPrix();
Double prix2 = (Double)cd2.getPrix();
int result = prix1.compareTo(prix2);
//dans le cas ou 2 CD auraient le même prix...
if(result == 0){
return cd1.compareTo(cd2);
}
return result;
}

17
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)
});

it = list.iterator();
while(it.hasNext())
System.out.println(it.next());
}
}

Déjà, si vous voulez avoir une implémentation de Set triée, je vous invite à utiliser
l’objet TreeSet ou SortedSet. Pour pouvoir trier les objets que vous insérerez dans ce genre
de collections, il faudra que ces objets implémentent l'interface Comparable, ou bien que vous
passiez par un comparateur dans le constructeur. Voici un code d'exemple :
import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Main6 {


public static void main(String[] args){
Set<CD> set1 = new TreeSet<CD>();
set1.add(new CD("Les arcandiers", "7€", 7d));
set1.add(new CD("Frank Zappa", "Tinseltown rebellion", 10.25d));
set1.add(new CD("Frank Zappa", "Bongo Fury", 10.25d));
set1.add(new CD("King Crimson", "red", 15.30d));
set1.add(new CD("Joe Zawinul", "World tour", 12.15d));

Iterator<CD> it = set1.iterator();
while(it.hasNext())
System.out.println(it.next());

//On crée directement un nouvel objet


//en lui spécifiant sa façon de ranger les objets
Set<CD> set2 = new TreeSet<CD>(new Comparator<CD>(){
public int compare(CD cd1, CD cd2) {
Double prix1 = (Double)cd1.getPrix();
Double prix2 = (Double)cd2.getPrix();
int result = prix1.compareTo(prix2);
//dans le cas ou 2 CD auraient le même prix...
if(result == 0){
return cd1.compareTo(cd2);
}
return result;
}
});

//On ajoute le contenu de la première collection


//dans la deuxième
set2.addAll(set1);
System.out.println("-------------------------------");
it = set2.iterator();
while(it.hasNext())
System.out.println(it.next());
}
}

Exemple:2

//la classe NomCompare permet de trier la liste des étudiants suivant les noms
import java.util.*;
public class NomComparator implements Comparator<Etudiant>{
public int compare(Etudiant o1, Etudiant o2)
{
String nom1=o1.getNom();
String nom2=o2.getNom();
if (nom1.compareTo(nom2))<0) return -1;
if (nom1.equals(nom2)) return 0;
else return 1;}}
//la classe AgeComparator permet de trier la liste des étudiants suivant le nom
import java.util.*;
public class AgeComparator implements Comparator<Etudiant>{
public int compare(Etudiant o1, Etudiant o2) {
int age1=o1.getAge();
int age2=o2.getAge();
if (age1<age2) return -1;
if (age1==age2) return 0;
else return 1;}

18
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)
// la classe GroupeTD
import java.util.*;
public class GroupeTD{
public List<Etudiant> etudiants;
public GroupeTD()
{etudiants=new ArrayList<Etudiant>();}
public void ajouter(Etudiant e)
{etudiants.add(e);}
public void trierNom()
{NomComparator <Etudiant> c = new NomComparator<Etudiant>();
Collections.sort(etudiants,c);}
public void trierAge()
{AgeComparator <Etudiant> c = new AgeComparator <Etudiant> ();
Collections.sort(etudiants,c);
}
public void afficher()
{ Iterator it= etudiants.iterator();
while (it.hasNext())
((Etudiant)(it.next())).affiche();
}
}
// la classe de test
import java.util.*;
public class Test{
public static void main (String args[]){
Etudiant etud1=new Etudiant("MOHAMED", "AYECHI",18);
Etudiant etud2=new Etudiant("ALI", "MARRAKCHI",32);
Etudiant etud3=new Etudiant("MOHAMED", "HAMZA",14);
GroupeTD info = new GroupeTD();
info.ajouter(etud1);
info.ajouter(etud2);
info.ajouter(etud3);
System.out.println("trie nom");
info.trierNom();
info.afficher();
System.out.println("trie age");
info.trierAge();
info.afficher();}}

9. Les collections gérées sous la forme clé/valeur


– Ce type de collection gère les éléments avec deux entités : une clé et une valeur associée. La clé doit
être unique donc il ne peut y avoir de doublons. En revanche la même valeur peut être associée à
plusieurs clés différentes.
– Avant l'apparition du framework collections, la classe dédiée à cette gestion était la classe Hashtable

9.1. Map
- Cette interface est une des deux racines de l'arborescence des collections. Les collections qui
implémentent cette interface ne peuvent contenir des doublons. Les collections qui implémentent cette
interface utilisent une association entre une clé et une valeur.
– Les tables sont des structures dans lesquelles les objets, au lieu d'être accessibles à l'aide d'un index
correspondant à leur position, le sont au moyen d'une clé.
– Une structure de type Map permet ainsi de stocker des couples clé/valeur. La notion d'ordre n'y est pas
pertinente.
– En Java, le type Map est une interface qui doit être implémentée par des classes et n'offre donc qu'une
structure de méthodes sans définitions
– Elle définit plusieurs méthodes pour agir sur la collection

Void clear() supprime toutes les paires clé/valeur de la collection.


boolean containsKey(Object key) retourne true si la collection contient une paire clé/valeur
correspondant à la clé spécifiée.
boolean containsValue(Object value) retourne true si la collection contient une ou plusieurs clés pointant la
valeur spécifiée.
Set entrySet() retourne un objet Set contenant toutes les entrées de la collection.
boolean equals(Object o) teste l'égalité entre l'objet Map et un autre objet.
Object get(Object key) retourne la valeur correspondant à la clé spécifiée.
int hashCode() retourne le code de hachage.
boolean isEmpty() retourne true si la collection ne contient aucune entrée.
Set keySet() retourne un objet Set contenant les clés de l'objet Map.

19
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)
Object put(Object key, Object value) associe la valeur spécifiée à la clé donnée au sein de la collection.

Void putAll(Map t) copie toutes les paires clé/valeur de la collection spécifiée au sein de
l'objet Map.

Object remove(Object key) supprime la paire clé/valeur correspondant à la clé spécifiée.


int size() retourne le nombre d'entrées dans la collection.
Collection values() retourne un objet Collection contenant les valeurs de l'objet Map.
– La méthode entrySet() permet d'obtenir un ensemble contenant toutes les clés.
– La méthode values() permet d'obtenir une collection contenant toutes les valeurs. La valeur de retour
est une Collection et non un ensemble car il peut y avoir des doublons (plusieurs clés peuvent être
associées à la même valeur).
– Le J.D.K. 1.2 propose deux nouvelles classes qui implémentent cette interface :
o HashMap qui stocke les éléments dans une table de hashage
o TreeMap qui stocke les éléments dans un arbre
– La classe HashTable a été mise à jour pour implémenter aussi cette interface

9.2. Interface SortedMap


- Cette interface définit une collection de type Map triée sur la clé. Elle hérite de l'interface Map.
- Le tri peut être assuré par deux façons :
o les clés contenues dans la collection implémentent l'interface Comparable pour définir leur ordre
naturel.
o il faut fournir au constructeur de la collection un objet Comparator qui définit l'ordre de tri à
utiliser.
- Elle définit plusieurs méthodes pour tirer parti de cet ordre :

Comparator comparator() renvoie l'objet qui permet de trier la collection


Object first() renvoie le premier élément de la collection
SortedSet headMap(Object) renvoie une sous collection contenant tous les éléments inférieurs à
celui fourni en paramètre
Object last() renvoie le dernier élément de la collection
SortedMap subMap(Object, Object) renvoie une sous collection contenant les éléments compris entre le
premier paramètre inclus et le second exclus
SortedMap tailMap(Object) renvoie une sous collection contenant tous les éléments supérieurs
ou égaux à celui fourni en paramètre

9.3. L’interface NavigableMap


-L’interface NavigableMap étend l’interface SortedMap par des méthodes de navigation (mettre en ordre
croissant ou décroissant, trouver des nombre supérieur à un nombre ou inférieur à…).
-Parmi les méthodes de l’interface NavigableMap on peut citer :

Entry <K,V> ceilingEntry(K key) Renvoie une entrée (clé, valeur) du Map associée à la plus petite clé
supérieure ou égale à la clé donnée, ou null s'il n'y a pas cette clé.
Entry <K,V> floorEntry(K key) Renvoie une entrée (clé, valeur) associée à la plus grande clé inférieure ou
égale à la clé donnée, ou null s'il n'y a pas cette clé.
higherEntry(E e) Renvoie une entrée (clé, valeur) associée à la plus petite clé strictement
supérieur à la clé donnée, ou null s'il n'y a pas cette clé.
lowerkey(E e) Renvoie une entrée (clé, valeur) associée à la plus grande clé strictement
inférieure à la clé donnée, ou null s'il n'y a pas cette clé.
descendingSetMap() Renvoie les éléments en ordre inverse

Exemple :
import java.util.*;
import java.util.concurrent.*;
public class NavigableMapExample{
public static void main(String[] args) {
System.out.println("Navigable Map Example!\n");
NavigableMap <Integer, String>navMap = new ConcurrentSkipListMap<Integer, String>();
navMap.put(1, "January"); navMap.put(2, "February"); navMap.put(3, "March"); navMap.put(4, "April");
navMap.put(5, "May"); navMap.put(6, "June"); navMap.put(7, "July"); navMap.put(8, "August");
navMap.put(9, "September"); navMap.put(10, "October");
navMap.put(11, "November"); navMap.put(12, "December");
//Displaying all data
System.out.println("Data in the navigable map: " + navMap.descendingMap()+"\n");
//Retrieving first data
System.out.print("First data: " + navMap.firstEntry()+"\n");
//Retrieving last data
System.out.print("Last data: " + navMap.lastEntry()+"\n\n");
//Retrieving the nreatest less than or equal to the given key
20
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)
System.out.print("Nearest less than or equal to the given key: " + navMap.floorEntry(5)+"\n");
//Retrieving the greatest key strictly less than the given key
System.out.println("Retrieving the greatest key strictly less than the given key: " + navMap.lowerEntry(3));
//Retrieving a key-value associated with the least key
strictly greater than the given key
System.out.println("Retriving data from navigable map greter than the given key: "
+ navMap.higherEntry(5)+"\n");
//Removing first
System.out.println("Removing First: " + navMap.pollFirstEntry());
//Removing last
System.out.println("Removing Last: " + navMap.pollLastEntry()+"\n");
//Displaying all data
System.out.println("Now data: " + navMap.descendingMap());
}
}
L’output est :
Navigable Map Example!
Data in the navigable map: {12=December, 11=November, 10=October, 9=September, 8
=August, 7=July, 6=June, 5=May, 4=April, 3=March, 2=February, 1=January}

First data: 1=January


Last data: 12=December

Nearest less than or equal to the given key: 5=May


Retrieving the greatest key strictly less than the given key: 2=February
Retriving data from navigable map greter than the given key: 6=June

Removing First: 1=January


Removing Last: 12=December

Now data: {11=November, 10=October, 9=September, 8=August, 7=July, 6=June, 5=May


, 4=April, 3=March, 2=February}

9.4. La classe Hashtable


- Cette classe implémente une table de hachage.
- La clé et la valeur de chaque élément de la collection peut être n'importe quel objet non nul.

Exemple:
import java.util.*;
public class TestHashtable {
public static void main(String[] args) {
Hashtable htable = new Hashtable();
htable.put(new Integer(3), "données 3");
htable.put(new Integer(1), "données 1");
htable.put(new Integer(2), "données 2");
System.out.println(htable.get(new Integer(2)));
}
}
Résultat :
données 2

9.5. La classe HashMap


- La classe HashMap est similaire à la classe Hashtable.
- Elle possède quelques différences (elle autorise les objets null comme clé ou valeur…).
Exemple:
import java.util.*;
public class TestHashMap {
public static void main(String[] args) {
HashMape<Integer, String> hMap = new HashMap<Integer, String> ();
hMap.put(new Integer(3), "données 3");
hMap.put(new Integer(1), "données 1");
hMap.put(new Integer(2), "données 2");
System.out.println(hMap.get(new Integer(2))); }}
Résultat :
données 2

9.6. La classe TreeMap


- Cette classe gère une collection d'objets sous la forme clé/valeur stockés dans un arbre.
- Elle implémente l'interface SortedMap.
- L'ordre des éléments de la collection est maintenu grâce à un objet de type Comparable.
- Elle possède plusieurs constructeurs dont un qui permet de préciser l'objet Comparable pour définir
l'ordre dans la collection.
-

21
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

Exemple :
import java.util.*;
public class TestTreeMap {
public static void main(String[] args) {
TreeMap<Integer, String> arbre = new TreeMap<Integer, String> ();
arbre.put(new Integer(3), "données 3"); arbre.put(new Integer(1), "données 1");
arbre.put(new Integer(2), "données 2");
Set cles = arbre.keySet(); Iterator iterator = cles.iterator();
while (iterator.hasNext()) {
System.out.println(arbre.get(iterator.next()));
} }}
Résultat :
données 1
données 2
données 3
Exemple:
import java.util.*;
public class TreeMapExample{
public static void main(String[] args) {
System.out.println("Tree Map Example!\n");
TreeMap <Integer, String>tMap = new TreeMap<Integer, String>();
//Addding data to a tree map
tMap.put(1, "Sunday"); tMap.put(2, "Monday"); tMap.put(3, "Tuesday");
tMap.put(4, "Wednesday");tMap.put(5, "Thursday");tMap.put(6, "Friday");
tMap.put(7, "Saturday");
//Rerieving all keys
System.out.println("Keys of tree map: " + tMap.keySet());
//Rerieving all values
System.out.println("Values of tree map: " + tMap.values());
//Rerieving the value from key with key number 5
System.out.println("Key: 5 value: " + tMap.get(5)+ "\n");
//Rerieving the First key and its value
System.out.println("First key: " + tMap.firstKey() + " Value: "
+ tMap.get(tMap.firstKey()) + "\n");
//Rerieving the Last key and value
System.out.println("Last key: " + tMap.lastKey() + " Value: "
+ tMap.get(tMap.lastKey()) + "\n");
//Removing the first key and value
System.out.println("Removing first data: " + tMap.remove(tMap.firstKey()));
System.out.println("Now the tree map Keys: " + tMap.keySet());
System.out.println("Now the tree map contain: " + tMap.values() + "\n");
//Removing the last key and value
System.out.println("Removing last data: " + tMap.remove(tMap.lastKey()));
System.out.println("Now the tree map Keys: " + tMap.keySet());
System.out.println("Now the tree map contain: " + tMap.values());
}
}

L’output est :
Tree Map Example!

Keys of tree map: [1, 2, 3, 4, 5, 6, 7]


Values of tree map: [Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]
Key: 5 value: Thursday

First key: 1 Value: Sunday

Last key: 7 Value: Saturday

Removing first data: Sunday


Now the tree map Keys: [2, 3, 4, 5, 6, 7]
Now the tree map contain: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday]

Removing last data: Saturday


Now the tree map Keys: [2, 3, 4, 5, 6]
Now the tree map contain: [Monday, Tuesday, Wednesday, Thursday, Friday]

22
Chapitre 1 : Les collections(Listes, ensembles, tables associatives)

Résumé
Le tableau ci dessous présente les différentes classes qui implémentent les interfaces de bases Set, List et
Map :
Set: collection d'éléments List : collection avec Map : collection sous la
uniques doublons forme clé/valeur

Tableau ArrayList, Vector


redimensionnable

Arbre TreeSet TreeMap

Liste chaînée LinkedList

Collection utilisant une HashSet HashMap, HashTable


table de hashage

Le tableau ci dessous présente les caractéristiques de chaque interface :

Nom Interface Ordonnée Peut contenir des Utilisation des clés


doublons
Collection No Yes No
Set No No No
List Yes Yes No
Map No No Yes
SortedSet Yes No No
SortedMap Yes No Yes

Le tableau suivant présente les caractéristiques des classes qui implémentent les interfaces :

23

Vous aimerez peut-être aussi