FAQ Langage JavaConsultez toutes les FAQ

Les collections font partie du JDK depuis la version 1.2. Les collections proposent une s�rie de classes, d'interfaces et d'impl�mentations pour g�rer efficacement les donn�es.

Pour chaque type de structure de donn�es (liste, ensemble, association), il existe une interface et plusieurs impl�mentations. Chaque impl�mentation utilise une strat�gie avec des avantages et des inconv�nients. Il est important de bien comprendre les diff�rentes strat�gies pour choisir l'impl�mentation la plus performante en fonction de ses besoins.

Conseil
Tout d'abord, afin de minimiser la quantit� de code � modifier pour changer d'impl�mentation, il convient de toujours faire r�f�rence aux collections en utilisant les interfaces, seule l'�tape de construction faisant r�f�rence � l'impl�mentation.

1
2
3
4
5
6
7
8
// La bonne solution�:  
List<Object> list = new ArrayList<>(); 
Set<Object> set = new HashSet<>(); 
Map<Object> map = new TreeMap<>(); 
// La mauvaise solution�:  
ArrayList<Object> list = new ArrayList<>(); 
HashSet<Object> set = new HashSet<>(); 
TreeMap<Object> map = new TreeMap<>();

• java.util.Set - un ensemble�: un groupe d'�l�ments uniques�;
• java.util.List - une liste�: une suite d'�l�ments ordonn�s accessibles par leur indice (leur place dans la liste). Les listes ne garantissent pas l'unicit� des �l�ments�;
• java.util.Map - un dictionnaire ou une association�: ils m�morisent une collection de couples cl�-valeur. Si vous avez une cl�, l'association retrouvera la valeur associ�e � cette cl�. Les cl�s sont uniques, mais la m�me valeur peut-�tre associ�e � plusieurs cl�s.
  

L'API propose trois impl�mentations concr�tes pour les ensembles (java.util.Set). Un ensemble est un groupe d'�l�ments uniques.

HashSet
La classe java.util.HashSet est la plus utile des impl�mentations. L'ordre d'it�ration des �l�ments de cette collection est al�atoire.
Les op�rations add(), remove(), contains() and size() sont ex�cut�es en un temps constant.

TreeSet
La classe java.util.TreeSet contient un ensemble d'�l�ments ordonn�s�: elle impl�mente �galement l'interface java.util.SortedSet. Les �l�ments sont ordonn�s en fonction de leur ordre naturel (voir java.util.Comparable), ou en fonction d'un java.util.Comparator pr�cis� � la construction du TreeSet.
Les op�rations add(), remove(), contains() and size() sont ex�cut�es en un temps log(n).

LinkedHashSet
La classe java.util.LinkedHashSet est identique au HashSet sauf qu'elle conserve l'ordre d'insertion des �l�ments dans une liste doublement cha�n�e. L'ordre d'it�ration des �l�ments correspond � l'ordre d'insertion, l'ordre reste inchang� si l'on ajoute un �l�ment d�j� pr�sent.
Les op�rations add(), remove(), contains() and size() sont ex�cut�es en un temps constant (mais sup�rieur au temps du HashSet, car il faut �galement g�rer la liste cha�n�e).

L'API propose deux impl�mentations concr�tes pour les listes (java.util.List). Une liste est une suite ordonn�e d'�l�ments. Un �l�ment peut �tre ajout� � plusieurs endroits dans une m�me liste.

ArrayList
La classe java.util.ArrayList utilise un tableau en interne pour ranger les donn�es. Un ArrayList fournit un acc�s aux �l�ments par leur indice tr�s performant et est optimis� pour des op�rations d'ajout/suppression d'�l�ments en fin de liste.

Les donn�es de la liste sont rang�es dans un tableau d'objets. Le principal int�r�t d'un ArrayList �tant de pouvoir facilement ajouter un �l�ment � la liste, le tableau utilis� en interne est surdimensionn� par rapport au besoin. Par exemple�: un ArrayList de 5 �l�ments pourrait utiliser un tableau de 10 �l�ments, lorsqu'on ajoute un nouvel �l�ment, on le place dans la 1^re case libre du tableau interne, on n'est pas oblig� d'instancier un nouveau tableau. �videmment, � force d'ajouter des �l�ments, le tableau interne peut se trouver satur�, dans ce cas un nouveau tableau est cr�� et les anciennes valeurs sont recopi�es dedans.

La gestion automatique de la taille du tableau interne ne nous emp�che pas de donner un coup de main pour am�liorer les performances. Lors de la cr�ation d'une liste, il est important d'utiliser un constructeur pr�cisant la capacit� (taille du tableau interne), il est en g�n�ral facile d'estimer la taille moyenne de sa structure de donn�es, on �vite ainsi de passer par plusieurs dizaines de r�allocations du tableau interne. De m�me, avant d'ins�rer une grande quantit� d'informations, il est possible de demander de garantir une capacit� minimale. Ces pr�cautions sont d'autant plus importantes si la liste contient beaucoup d'�l�ments.

De plus, le tableau contenu dans un ArrayList ne fait que grandir, il ne diminue jamais m�me en cas de suppression d'un ou de tous les �l�ments de la liste. Vous devez invoquer la m�thode trimToSize() de la liste pour r�duire la capacit� de stockage du tableau � la taille de la liste.

1
2
3
4
5
6
List<String> maListe = new ArrayList<>(2); // Pr�allocation d'un tableau de capacit� 2. 
maListe.add("Toto"); // La capacit� du tableau ayant �t� pr�allou�e, il n'est pas redimensionn�. 
maListe.add("Tata"); // Idem. 
maListe.add("Titi");  // Augmentation de la capacit� de stockage du tableau. 
maListe.remove("Titi"); // La capacit� de stockage du tableau reste inchang�e. 
maListe.trimToSize() // R�duction de la capacit� de stockage du tableau.

1
2
3
4
5
List<String> maListe = new LinkedList<>(); 
maListe.add("Toto"); // Cr�ation d'une nouvelle cellule de stockage 
maListe.add("Tata"); // Idem. 
maListe.add("Titi"); // Idem. 
maListe.remove("Titi"); // Suppression d'une cellule de stockage.

L'API propose cinq impl�mentations concr�tes pour les dictionnaires ou associations (java.util.Map). Une map permet de cr�er un ensemble de couples cl�/valeur�; on parle aussi de tableaux associatifs. La cl� permet de retrouver rapidement la valeur qui lui a �t� associ�e. Les cl�s sont des objets uniques pouvant �tre null. Les valeurs peuvent �tre multiples et null.

HashMap
La classe java.util.HashMap est l'impl�mentation concr�te la plus standard, elle est adapt�e � la plupart des situations.

1
2
3
4
5
6
Map<Integer, String> monDictionnaire = new HashMap<>(); 
monDictionnaire.put(0, "Toto"); 
monDictionnaire.put(1, "Tata"); 
monDictionnaire.put(2, "Titi"); 
monDictionnaire.put(2, null); // �crase la valeur "Titi". 
String value = monDictionnaire.get(0); // Retourne "Toto".

1
2
3
4
Map<Integer, String> monDictionnaire = new TreeMap<>(); 
monDictionnaire.put(0, "Toto"); 
monDictionnaire.put(1, "Tata"); 
monDictionnaire.put(2, "Titi");

1
2
3
4
5
6
Map<Integer, String> monDictionnaire = new HashMap<>(); 
// Toutes les op�rations pour ajouter les �l�ments...  
monDictionnaire .put(....); 
[...] 
// ... puis on construit la TreeMap.  
monDictionnaire = new TreeMap<>(monDictionnaire);

Pour cr�er une collection en lecture seule, il suffit d'invoquer une des m�thodes unmodifiableXXX() de la classe java.util.Collections. Ces m�thodes prennent une collection (ensemble, liste, dictionnaire) en param�tre et retournent une collection du m�me type qui ne peut pas �tre modifi�e�: c'est-�-dire dont les m�thodes qui permettent de modifier le contenu (retrait, ajout, changement de valeur) de la collection l�vent une exception lorsqu'on les invoque. La nouvelle collection empaqu�te la collection d'origine�; il n'y a donc pas de duplication de donn�es ou de structure de stockage.

• unmodifiableCollection() - permet de cr�er une collection non modifiable (qui r�pond � l'interface java.util.Collection)�;
• unmodifiableList() - permet de cr�er une liste non modifiable�;
• unmodifiableMap() - permet de cr�er un dictionnaire non modifiable�;
• unmodifiableNavigableMap() - permet de cr�er un dictionnaire navigable non modifiable�;
• unmodifiableNavigableSet() - permet de cr�er un ensemble navigable non modifiable�;
• unmodifiableSet() - permet de cr�er un ensemble non modifiable�;
• unmodifiableSortedMap() - permet de cr�er un dictionnaire ordonn� non modifiable�;
• unmodifiableSortedSet() - permet de cr�er un ensemble ordonn� non modifiable.
  

1
2
List<String> maListe = Arrays.asList("Toto", "Titi", "Tata"); 
List<String> maListeLectureSeule = Collections.unmodifiableList(maListe);

1
2
3
4
String value = maListeLectureSeule.get(0); // Ok. 
maListeLectureSeule.add("Tutu"); // G�n�re une exception de type UnsupportedOperationException. 
maListeLectureSeule.remove(1); // G�n�re une exception de type UnsupportedOperationException. 
maListeLectureSeule.clear(); // G�n�re une exception de type UnsupportedOperationException.

Pour cr�er une collection synchronis�e, il suffit d'invoquer une des m�thodes synchronizedXXX() de la classe java.util.Collections. Ces m�thodes prennent une collection (ensemble, liste, dictionnaire) en param�tre et retournent une collection du m�me type dont les m�thodes sont synchronis�es�: c'est-�-dire qu'il est possible de poser des s�maphores sur ces m�thodes lors d�acc�s � la collection par des processus (threads) concurrents. La nouvelle collection empaqu�te la collection d'origine�; il n'y a donc pas de duplication de donn�es ou de structure de stockage.

• synchronizedCollection() - permet de cr�er une collection synchronis�e (qui r�pond � l'interface java.util.Collection)�;
• synchronizedList() - permet de cr�er une liste synchronis�e�;
• synchronizedMap() - permet de cr�er un dictionnaire synchronis�;
• synchronizedNavigableMap() - permet de cr�er un dictionnaire navigable synchronis�e�;
• synchronizedNavigableSet() - permet de cr�er un ensemble navigable synchronis�e�;
• synchronizedSet() - permet de cr�er un ensemble synchronis�;
• synchronizedSortedMap() - permet de cr�er un dictionnaire ordonn� synchronis�;
• synchronizedSortedSet() - Permet de cr�er un ensemble ordonn� synchronis�.
  

1
2
List<String> maListe = Arrays.asList("Toto", "Titi", "Tata"); 
List<String> maListeSynchronisee = Collections.synchronizedList(maListe);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Il faut synchroniser les acc�s en lecture. 
synchronized (maListeSynchronisee) { 
    String value = maListeSynchronisee.get(0); 
} 
// Et en �criture. 
synchronized (maListeSynchronisee) { 
    maListeSynchronisee.add("Tutu"); 
} 
// De m�me que les it�rateurs. 
synchronized (maListeSynchronisee) { 
    Iterator i = maListeSynchronisee t.iterator(); 
    while (i.hasNext()) { 
        faireQuelqueChose(i.next()); 
    } 
} 
// Ou les flux. 
synchronized (maListeSynchronisee) { 
    maListeSynchronisee.stream() 
        .forEach(System.out::println); 
} 
// Ou toute op�ration qui touche au contenu de la liste. 
synchronized (maListeSynchronisee) { 
    Collections.sort(maListeSynchronisee); 
}

Comme nous l'avons indiqu� plus haut, il est d�conseill� d'utiliser la classe Vector. En effet, celle-ci fait partie des vieilles classes de Java�1.0 qui datent d'avant l'ajout du framework de collections. Ses m�thodes ne respectent donc pas les standards de nommage des collections. De plus, cette classe est synchronis�e, c'est-�-dire qu'elle peut s'utiliser dans un environnement multithread� mais cela r�sulte en une perte de performances.

Il vaut donc mieux utiliser la classe ArrayList qui s'utilise presque de la m�me mani�re que Vector, mais qui n'est pas synchronis�e et fait partie des nouvelles classes du framework. Si vous avez tout de m�me besoin d'une collection synchronis�e du type de Vector, il vous suffit d'invoquer la m�thode synchronizedList() de la classe Collections�:

1
2
3
List<Voiture> listeVoiture = new ArrayList<>([...]);  
[...] 
listeVoiture  = Collections.synchronizedList(listeVoiture);

Comme nous l'avons indiqu� plus haut, il est d�conseill� d'utiliser la classe Hashtable. En effet, celle-ci fait partie des vieilles classes de Java�1.0 qui datent d'avant l'ajout du framework de collections. Ses m�thodes ne respectent donc pas les standards de nommage des collections. De plus, cette classe est synchronis�e, c'est-�-dire qu'elle peut s'utiliser dans un environnement multithread�, mais cela r�sulte en une perte de performances.

De plus, il n'est pas possible de stocker une valeur null dans ce type de dictionnaire�: invoquer la m�thode put() avec une valeur null g�n�rera une exception de type java.lang.NullPointerException.

1
2
3
4
5
6
Map<String, Object> map = new Hashtable<>();  
[...]  
map.put("toto", null); // G�n�re une NullPointerException.  
// Pr�f�rer�:  
map.remove("toto");  
Object valeur = map.get("toto"); // Valeur est � null.

1
2
3
Map<Integer, Voiture> dictionnaireVoiture = new HashMap<>();   
[...] 
dictionnaireVoiture = Collections.synchronizedMap(dictionnaireVoiture);

Il existe plusieurs mani�res de cr�er une pile (LIFO ou Last In - First Out ou ��dernier entr� - premier sorti��)�:

Stack
La classe java.util.Stack pourrait correspondre � nos besoins, mais elle h�rite de Vector�; ces m�thodes sont donc synchronis�es et plus lentes que si l'on cr�ait une pile en se basant sur une collection de l'API Java�2�:

• �criture sur la pile�: push()�;
• Retrait de la pile�: pop()�;
• Lecture de la pile�: peek().
  

• �criture sur la pile�: addFirst() et offerFirst()�;
• Retrait de la pile�: removeFirst() et pollFirst�;
• Lecture de la pile�: peekFirst() et getFirst().
  

Il existe plusieurs mani�res de cr�er une file (FIFO ou First In - First Out ou ��premier entr� - premier sorti��) �:

Queue
L'interface java.util.Queue introduite dans le JDK�5 peut �tre utilis�e pour manipuler une file via ses m�thodes�:

• �criture en fin de file�: add() et offer()�;
• Retrait en t�te de file�: remove() et poll()�;
• Lecture en t�te de file �: element() et peek().
  

• �criture en fin de file�: addLast() et offerLast()�;
• Retrait en t�te de file�: removeFirst() et pollFirst()�;
• Lecture en t�te de file�: getFirst() et peekFirst().
  

Pour trier le contenu d'une liste, il suffit d'invoquer une des variantes de la m�thode sort() de la classe utilitaire java.util.Collections�:

1
2
3
4
5
6
List<Object> maListe = new ArrayList<>(); 
[...] 
Collections.sort(maListe); 
// Ou�:  
Comparator<Object> unComparateur = [...] // Permet de comparer les objets de la liste entre eux. 
Collections.sort(maListe, unComparateur);

Collections.sort(maListe, Collections.reverseOrder());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Voiture {  
    String marque = "";  
    int nbChevaux = 0;  
  
    public Voiture(String s, int i) {  
        marque = s;  
        nbChevaux = i;  
    }  
  
    public int getNbChevaux()  {  
        return nbChevaux;   
    } 
  
    public String toString()  {  
        return marque + "\t" + nbChevaux;    
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Voiture implements java.lang.Comparable {  
  
   [...] 
  
    // m�thode � impl�menter 
    /** 
     * @param other Doit �tre de type Voiture�! 
     */ 
    public int compareTo(Object other) {  
        int nombre1 = ((Voiture) other).getNbChevaux();  
        int nombre2 = this.getNbChevaux();  
        return nombre2 - nombre1;  
   }  
}

Collections.sort(listeVoiture);

Il existe plusieurs mani�res de parcourir tous les �l�ments d'un ensemble�:

It�rateur
On peut parcourir une collection de type Set au moyen d'un it�rateur. Il suffira alors d'invoquer la m�thode iterator() de la collection et de le parcourir avec une boucle for traditionnelle�:

1
2
3
4
5
6
Set<Voiture> ensembleVoiture = [...]  
[...] 
for (Iterator<Voiture> i = ensembleVoiture.iterator()�; i.hasNext()�; ) {     
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
6
7
Set<Voiture> ensembleVoiture  = [...]  
[...] 
Iterator<Voiture> i = ensembleVoiture.iterator(); 
while (i.hasNext()) {  
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
Set<Voiture> ensembleVoiture = [...]  
[...] 
for (Voiture value�: ensembleVoiture) { 
    System.out.println(value);  
}

1
2
3
4
Set<Voiture> ensembleVoiture = [...]  
[...] 
ensembleVoiture.stream() 
    .forEach(System.out::println);

Il existe deux mani�res simples de convertir une liste en tableau.

List.toArray()
Cette premi�re m�thode, qui ne prend pas de param�tre, permet de convertir une liste en un tableau d'objet (Object[]).

1
2
List<String> liste = Arrays.asList("Toto", "Tata", "Titi"); 
Object[] tableau = liste.toArray();

1
2
3
4
List<String> liste = Arrays.asList("Toto", "Tata", "Titi"); 
String[] tableau = liste.toArray(new String[0]); // Alloue un nouveau tableau pour le r�sultat. 
String[] tableau = liste.toArray(new String[10]); // Conserve le tableau passe en param�tre car la capacit� est suffisante. 
String[] tableau = liste.toArray(null); // L�ve une exception de type NullPointerException.

La conversion d'un ensemble (Set) vers un tableau se fait en utilisant la m�thode toArray.

1
2
3
4
5
 
Set<String> sourceSet = new HashSet<String>(); 
sourceSet.add("message1"); 
sourceSet.add("message2"); 
String[] targetArray = sourceSet.toArray(new String[sourceSet.size()]);

Les moyens les plus simples de convertir un tableau en liste sont soit de cr�er une nouvelle ArrayList � partir du tableau source, soit d'invoquer la m�thode toList() de la classe java.util.Arrays (qui effectue la m�me chose).

1
2
3
4
String[] tableau = { "Toto", "Tata", "Titi" }; 
List<String> liste = new ArrayList<>(tableau); 
// Ou  
List<String> liste = Arrays.asList(tableau); // Fait exactement la m�me chose.

Deux fa�ons sont disponibles pour convertir un tableau via un ensemble (Set).

Lors de la construction du Set

1
2
3
 
String[] sourceArray = { "message1", "message2", "message3", "message4" }; 
Set<String> targetSet = new HashSet<String>(Arrays.asList(sourceArray));

1
2
3
4
 
String[] sourceArray = { "message1", "message2", "message3", "message4" }; 
Set<string> targetSet = new HashSet<String>(); 
Collections.addAll(targetSet, sourceArray);

Il existe plusieurs mani�res de parcourir tous les �l�ments d'un dictionnaire.

It�rateur
On peut parcourir une collection de type Map au moyen d'it�rateurs. Pour cela, il suffit de r�cup�rer soit les couples (cl�, valeur), soit les cl�s, soit les valeurs contenues dans le dictionnaire avec, respectivement, les m�thodes entrySet(), keySet() et values(). Il suffira alors d'invoquer la m�thode iterator() de la collection obtenue et de le parcourir avec une boucle for traditionnelle�:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Map<Integer, Voiture> dictionnaireVoiture  = [...]  
[...] 
// Parcours sur les couples de la table.  
for (Iterator<Map.Entry<Integer, Voiture>> i = dictionnaireVoiture.entrySet().iterator()�; i.hasNext()�; ) { 
    Map.Entry<Integer, Voiture> entry = i.next(); 
    System.out.println(entry);  
} 
// Parcours sur les cl�s de la table. 
for (Iterator<Integer> i = dictionnaireVoiture.keySet().iterator()�; i.hasNext()�; ) { 
    Integer key = i.next(); 
    System.out.println(key);  
} 
// Parcours sur les valeurs de la table. 
for (Iterator<Voiture> i = dictionnaireVoiture.values().iterator()�; i.hasNext()�; ) {  
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Map<Integer, Voiture> dictionnaireVoiture  = [...]  
[...] 
// Parcours sur les couples de la table.  
Iterator<Map.Entry<Integer, Voiture>> i = dictionnaireVoiture.entrySet().iterator(); 
while (i.hasNext()) { 
    Map.Entry<Integer, Voiture> entry = i.next(); 
    System.out.println(entry);  
} 
// Parcours sur les cl�s de la table. 
Iterator<Integer> i = dictionnaireVoiture.keySet().iterator(); 
while (i.hasNext()) { 
    Integer key = i.next(); 
    System.out.println(key);  
} 
// Parcours sur les valeurs de la table. 
Iterator<Voiture> i = dictionnaireVoiture.values().iterator(); 
while (i.hasNext()) {  
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// Mieux vaut faire�: 
for (Iterator<Map.Entry<Integer, Voiture>> i = dictionnaireVoiture.entrySet().iterator()�; i.hasNext()�; ) { 
    Map.Entry<Integer, Voiture> entry = i.next(); 
    Integer key = entry.getKey(); 
    Voiture value = entry.getValue(); 
    System.out.println("key = " + key + " value = " + value);  
} 
// Que�: 
for (Iterator<Integer> i = dictionnaireVoiture.keySet().iterator()�; i.hasNext()�; ) { 
    Integer key = i.next(); 
    Voiture value = dictionnaireVoiture.get(key); // Pas performant�! 
    System.out.println("key = " + key + " value = " + value);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Map<Integer, Voiture> dictionnaireVoiture  = [...]  
[...] 
// Parcours sur les couples de la table.  
for (Map.Entry<Integer, Voiture> entry�: dictionnaireVoiture.entrySet()) { 
    System.out.println(entry);  
} 
// Parcours sur les cl�s de la table. 
for (Integer key�: dictionnaireVoiture.keySet()) { 
    System.out.println(key);  
} 
// Parcours sur les valeurs de la table. 
for (Voiture value�: dictionnaireVoiture.values()) { 
    System.out.println(value);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Map<Integer, Voiture> dictionnaireVoiture  = [...]  
[...] 
// Parcours sur les couples de la table.  
dictionnaireVoiture.entrySet() 
    .stream() 
    .forEach(System.out::println); 
// Parcours sur les cl�s de la table. 
dictionnaireVoiture.keySet() 
    .stream() 
    .forEach(System.out::println); 
// Parcours sur les valeurs de la table. 
dictionnaireVoiture.values() 
    .stream() 
    .forEach(System.out::println);

Il existe plusieurs mani�res de parcourir tous les �l�ments d'une liste�:

Boucle for ou while
Nous pouvons effectuer le parcours � l'ancienne, avec une boucle for traditionnelle, par exemple�:

1
2
3
4
5
6
List<Voiture> listeVoiture = [...]  
[...] 
for (int index = 0�; index < listeVoiture.size()�; index++) {     
    Voiture value = listeVoiture.get(index); // Pas performant�! 
    System.out.println(value);  
}

1
2
3
4
5
6
7
List<Voiture> listeVoiture = [...]  
[...] 
while (index < listeVoiture.size()) {     
    Voiture value = listeVoiture.get(index); // Pas performant�! 
    System.out.println(value);   
    index++; 
}

1
2
3
4
5
6
List<Voiture> listeVoiture = [...]  
[...] 
for (Iterator<Voiture> i = listeVoiture.iterator()�; i.hasNext()�; ) {     
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
6
7
List<Voiture> listeVoiture = [...]  
[...] 
Iterator<Voiture> i = listeVoiture.iterator(); 
while (i.hasNext()) {  
    Voiture value = i.next(); 
    System.out.println(value);  
}

1
2
3
4
5
List<Voiture> listeVoiture = [...]  
[...] 
for (Voiture value�: listeVoiture) { 
    System.out.println(value);  
}

1
2
3
4
List<Voiture> listeVoiture = [...]  
[...] 
listeVoiture.stream() 
    .forEach(System.out::println);

Dans un dictionnaire, il n'y a pas de notion d'ordre vu que l'on n'acc�de g�n�ralement pas � ses �l�ments par indice comme dans une liste, mais plut�t par des cl�s. Trier un objet de type Map suivant les valeurs revient en fait �:

• soit copier la liste des valeurs du Map dans une liste ou un tableau et trier ce conteneur. L'inconv�nient est que l'on ne travaille plus sur le dictionnaire et donc on n'a plus un acc�s direct aux �l�ments par cl�s�;
• soit r�cup�rer l'ensemble des cl�s du dictionnaire dans une liste, la trier suivant les valeurs et acc�der aux �l�ments du dictionnaire parcourant s�quentiellement les �l�ments de cette collection. Cette mani�re de faire n'est pas vraiment optimis�e compte tenu du nombre d�acc�s n�cessaires pour r�cup�rer les valeurs lors des tests�;
• ou encore r�cup�rer l'ensemble des couples du dictionnaire dans une liste, la trier suivant les valeurs et acc�der aux valeurs en parcourant s�quentiellement les couples contenus dans cette collection. L'avantage est qu'on acc�de toujours aux �l�ments directement par le couple contenu dans l'association. C'est � cette m�thode que l'on s'int�ressera.
  

1
2
3
4
5
6
7
8
 public class Personne { 
    private Long id; // Identifiant d'une personne. 
    private int age; 
    private String nom; 
  
    // Impl�menter les getters et les setters. 
   [...] 
}

Map<Long, Personne> personnes;

1. Commen�ons par cr�er un Comparator qui permet de comparer deux entr�es du dictionnaire suivant l'�ge des personnes qu'elles contiennent.
   
   

   Code Java :

   S�lectionner tout

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   public class PersonneComparator implements Comparator<Map.Entry<Long, Personne>> { 
     
       public PersonneComparator() { 
       } 
     
       @Override 
       public int compare(Map.Entry<Long, Personne> entry1, Map.Entry<Long, Personne> entry2) { 
           Personne p1 = entry1.getValue(); 
           Personne p2 = entry2.getValue();  
           // Comparer les deux couples en fonction de l'�ge des personnes contenues. 
           return p1.getAge() - p2.getAge(); 
       } 
   }

2. Trier les cl�s du dictionnaire en utilisant ce Comparator�:
   
   

   Code Java :

   S�lectionner tout

   1
   2
   List<Map.Entry<Long, Personne>> entries = new ArrayList<>(personnes.entrySet()); 
   Collections.sort(entries, new PersonneComparator());

3. Acc�der aux �l�ments du dictionnaire en utilisant la liste tri�e�:
   
   

   Code Java :

   S�lectionner tout

   1
   2
   3
   4
   5
   for (Map.Entry<Long, Personne> entry�: entries){ 
       Long cle = entry.getKey(); 
       Personne personne = entry.getValue(); 
       [...] 
   }

1
2
3
4
5
6
7
8
personnes.entrySet() 
    .stream() 
    .sorted(new PersonneComparator()) 
    .forEach(entry -> { 
        Long cle = entry.getKey(); 
        Personne personne = entry.getValue();   
        [...]       
    });