COLLECTIONS EN JAVA

3IIR - POO2
 LES COLLECTIONS EN JAVA ?

• Les collections représentent les structures de stockage standards (tableaux, listes

chaînées, ensembles, dictionnaires).

• Elles permettent de stocker des objets et de les manipuler de manière homogène.

• Elles prennent en charge les opérations courantes comme l’ajout, la suppression, la

recherche, le tri, …etc. en fournissant les méthodes nécessaires pour cela.

2
 L’API COLLECTIONS
• Les collections font partie de la Java Collections Framework. C’est l’API officielle de
Java pour gérer les collections d’objets.

• Située dans le package [Link]

• Composée d’un ensemble d’interfaces et de classes qui implémentent ces interfaces.

• Faciles à utiliser : syntaxe claire et cohérente.

• Permettent de produire du code fiable et performant.

• Offrent une grande souplesse et flexibilité, dans la gestion des groupes d’objets, par
rapport aux tableaux classiques.

3
 INTERFACES PRINCIPALES
• List, Queue, Set et Map sont les principales interfaces de l’API Collections.
Donne la capacité à une
collection d’être parcourue avec
une boucle forEach.
Map n'hérite pas
Décrit les capacités des de Collection, mais fait
collections, telles que
l'ajout, la modification, la partie intégrante du
suppression d'éléments. Framework

List, Queue et Set

héritent de Collection

4
 INTERFACES PRINCIPALES
• List : liste ordonnée d’éléments qui sont accessibles directement via un indice entier.

• Queue : file d’attente qui ordonne ses éléments selon un ordre FIFO, mais pouvant être LIFO

selon l’implémentation utilisée.

• Set : ensemble d’éléments qui n’autorise pas les doublons.

• Map : Chaque élément est une paire clé/valeur. Il permet d’associer des clés à des valeurs,

sans autoriser les clés dupliquées.

5
 INTERFACES PRINCIPALES

• L’API propose des interfaces pour des raisons de flexibilité.

• En programmant avec des interfaces plutôt qu’avec des classes concrètes, un

programme n’est pas lié à une implémentation spécifique.

• Cela permet de remplacer facilement une classe par une autre plus performante, à
condition qu’elle implémente la même interface.

• Ainsi, on peut par exemple remplacer un ArrayList par un LinkedList sans modifier le
reste du code, car les deux classes implémentent l’interface List.

6
 CLASSES DE L’API
• Chaque interface est implémentée par un ensemble de classes, offrant chacune des fonctionnalités
spécifiques selon les besoins.
L'API Collections est comme une boîte à
outils :
• Chaque interface est une spécification
abstraite, et chaque classe est un outil
spécialisé qui répond à un type de
besoin précis.
• L’objectif est de choisir l’outil adapté
sans changer la structure du
programme, grâce à la puissance des
interfaces.

7
 COLLECTIONS : TYPE GÉNÉRIQUE
• Les collections en Java sont génériques => List<T>, set<T>, map<K,V> , …

• Cela veut dire qu'elles ont été conçues avec un type paramétré (souvent représenté par la lettre T), laissant ainsi
à l'utilisateur la possibilité de choisir le type des éléments que les collections vont contenir.
List<String> List<int>
List<T> List<double>
List<Integer>
Les collections en Java ne peuvent
List<Double> stocker que des objets pas des types
primitifs. Utilisez les classes wrapper
List<Vehicule> comme Integer, Double, Character,
List<String> spécifie que la liste
va contenir seulement des objets etc. qui permettent de traiter les types
de type String. List<Oiseau>
primitifs comme des objets.

• Cela garantit que seuls les objets du type spécifié peuvent être ajoutés à la collection (type safety).
8
 L’INTERFACE COLLECTION
• Collection est l’interface parente de List, Set et Queue. Elle fournit des méthodes de base communes à
toutes ces collections.
• boolean add(E element) : ajoute un élément et retourne si l’opération a réussi ou non.
• boolean remove(Object obj): supprime un élément et retourne si l’opération a réussi ou non (utilise equals).
• boolean isEmpty() : retourne true si la collection est vide.

• int size() : retourne le nombre d’éléments.

• void clear(): vide la collection.

• boolean contains(Object obj) : retourne true si l’élément existe (utilise equals).

• boolean equals(Object obj) : retourne true si les deux collections sont égales.

• Les interfaces List, Queue et Set étendent ces opérations de base en ajoutant leurs propres méthodes spécifiques.

9
LES LISTES : List
 L’INTERFACE LIST
• List<T> : Collection d’éléments (ordre d’insertion), qui accepte les doublons et qui permet l'accès direct aux
éléments via un index.

• Fournit des méthodes communes à toutes les listes, qui servent à manipuler les éléments via les index.

• void add (int index, E element) : Ajoute un élément à l’index indiqué et décale les autres éléments vers la fin.

• E get(int index) : Renvoie l’élément correspondant à l’index indiqué.

• E set(int index, E e) : Remplace l’élément à l’index indiqué et renvoie l’élément original. Lève une exception
IndexOutOfBoundsException si l’index est invalide..

• int indexOf(Object o) : Renvoie l’index du premier élément correspondant ou -1 s’il n’est pas trouvé.

• E remove(int index) : Supprime l’élément correspondant à l’index indiqué et décale les autres vers le début.

11
 LIST : ARRAYLIST VS LINKEDLIST
• Les principales classes qui implémentent l'interface, List, sont ArrayList et LinkedList.

Structure FIFO (First-In, First-Out)

Queue (FIFO)
File doublement chaînée
Stack (LIFO, pile)

Implémentation Stockage des Caractéristiques Quand l’utiliser ?

éléments
ArrayList<T> Tableau Accès rapide (O(1)) mais coûteux en ajout Liste avec beaucoup de
dynamique et suppression (O(n)) lectures, ou autant de
lectures que d’écritures.
LinkedList<T> Liste doublement Accès lent (O(n)) : doit parcourir la liste Si vous modifiez souvent
chaînée Mais insertion/suppression rapide (O(1)) la liste (ajouts,
suppressions). 12
 LIST : ARRAYLIST
Création d’un ArrayList
public static void main(String[] args) {

List<Integer> premiers = new ArrayList<Integer>(); Constructeur avec argument précisant la

capacité initiale
List<String> voitures = new ArrayList<>();

} public static void main(String[] args) {

List<Integer> premiers = new ArrayList<>(5);

Constructeur sans arguments créant une ArrayList vide ;
lors du premier ajout, un tableau de capacité 10 est alloué. }

List<> maliste = new ArrayList<Double>();

13
 LIST : LINKEDLIST
Création d’un LinkedList
public static void main(String[] args) {

List<String> voitures = new LinkedList<>();

}
Constructeur sans arguments, créant une liste chainée vide

public static void main(String[] args) {

LinkedList n’a pas de constructeur
List<Integer> premiers = new LinkedList<>(5);
qui prend un entier en argument.
}

14
LIST : ARRAYLIST VS LINKEDLIST
Constructeur ayant comme argument une autre collection

public static void main(String[] args) {

List<Integer> premiers = new ArrayList<>([Link](2,3,5,7,11));

List<Integer> nombres = new LinkedList<>(premiers);

[Link](……) : crée une liste non modifiable

List<Integer> uneListe = [Link](1,2,3);

[Link](4); // erreur car uneListe ne peut pas être modifiée

15
 LIST
• Il est recommandé de déclarer une collection en utilisant l’interface (comme List) plutôt que la classe
d’implémentation (comme ArrayList ou LinkedList)

• En utilisant les interfaces :

• On ne dépend que du contrat (l’interface), ce qui rend le code plus souple.

• On peut changer l’implémentation (ex. passer de ArrayList à LinkedList) sans modifier le

reste du code, tant qu’on respecte l’interface.

• On peut traiter différents types de collections de la même manière, en tirant parti du

polymorphisme.

16
 LIST
public static void main(String[] args) {
public static void main(String[] args) {
List<String> voitures = new LinkedList<>();
List<String> voitures = new ArrayList<>(); [Link]("Toyota");
[Link]([Link]()); // true [Link]("BMW");
[Link]([Link]()); // 0 [Link]("Audi");

//Ajouter des voitures [Link]([Link](0)); //Toyota

[Link]("Toyota"); [Link](0, "Jeep"); //remplace Toyota par Jeep
[Link]("BMW"); [Link]([Link]("Jeep")); // true
[Link]("Audi");
// Affichage avec forEach contains utilise
equals.
//Afficher avec for
for(String v : voitures) [Link](v -> [Link](v));

[Link](v); remove utilise // Jeep, BMW, Audi,

equals. }
//Supprimer Mercedes des voitures
[Link]([Link]("Mercedes"));// false

[Link]([Link]()); // 3
[Link](); //vide la collection

}
17
 LIST<T>
• Il est fortement recommandé d’utiliser la collection générique en Java.

public static void main(String[] args) {

List numbers = new ArrayList([Link](1,2,3)); // Warning
Integer element = (Integer)[Link](0); // cast obligatoire
[Link]("une chaine!"); // types incompatibles autorisés
}
public static void main(String[] args) {

List<Integer> numbers = new ArrayList<>([Link](1,2,3));

Integer element = [Link](0); // aucun cast requis
[Link]("une chaine!"); // ne compile pas
• En utilisant les collections génériques : }

• On spécifie le type des éléments qu’une collection peut contenir.

• On évite que des éléments de type non compatible soient ajoutés à la collection (code plus sûr)

• On évite les conversions de types (casts) inutiles.

18
LES ENSEMBLES : SET
 L’INTERFACE SET
• Set<T> : Correspond à la définition mathématique d’un ensemble => collection d’éléments sans doublons.

• Vous pouvez créer un Set non modifiable avec la méthode statique of

Set<Character> letters = [Link]('c', 'a', 't');

• Vous pouvez faire une copie non modifiable d’un Set existant avec la méthode copyOf

Set<Character> setCopie = [Link](letters);

• Set n’a pas de méthodes spécifiques à part celles héritées de Collection.

• Set est implémentée par les classes HashSet, LinkedHashSet et TreeSet

20
 IMPLÉMENTATIONS DU SET
Implémentation Stockage des éléments Caractéristiques Quand l’utiliser ?
HashSet<T> Table de hachage Accès très rapide, aucun ordre (aléatoire) Stocker des éléments uniques sans
souci d’ordre
LinkedHashSet<T> Table de hachage + liste Ordre d’insertion, légèrement plus lent que Mélanger entre HashSet et List
chaînée le HashSet

TreeSet<T> Arbre binaire Ordre naturel ( A-Z, 1-9), le plus lent Garder toujours l’ensemble trié

21
 IMPLÉMENTATIONS DU SET
HashSet => Ordre aléatoire
Un set stocke des éléments uniques!
Set<Integer> S = new HashSet<>();
boolean b1 = [Link](66);
boolean b2 = [Link](10);
boolean b3 = [Link](66);
boolean b4 = [Link](8);
TreeSet => Trié selon l’ordre naturel
//Affichage du set Set<Integer> S = new TreeSet<>();
for (Integer val: S) [Link](66);
[Link](val + ','); // ………………………………………… [Link](10);
[Link](8);
[Link](66);
LinkedHashSet => Ordre d’insertion //Affichage du set
[Link]([Link]::println);// ……………………………
Set<Integer> S = new LinkedHashSet<>();
[Link](8);
[Link](66); Un TreeSet n’autorise pas les valeurs null
[Link](10);
[Link](66);
// Affichage du set
[Link](e -> [Link](e));// ………………………………
22
 HASHSET
• Un HashSet peut être créé en utilisant :

1 Un constructeur sans argument, créant un ensemble vide avec une capacité initiale de 16 éléments.

Set<Integer> set = new HashSet<>();

2 Un constructeur avec une capacité initiale spécifique.

Set<Integer> set1 = new HashSet<>(50);

3 Toute autre collection (par exemple, une List) pour initialiser cet ensemble avec des valeurs initiales.
Set<Integer> set3 = new HashSet<>([Link](1,2,3));

23
 HASHSET : equals et hashcode
import [Link];
Un set stocke des éléments uniques!
public class Personne {
private String nom; Set<Personne> pers = new HashSet<>();
private int age;
[Link](new Personne("Alia", 25));
public Personne(String nom, int age) {
[Link] = nom;
[Link] = age; • Pour un HashSet, la méthode add utilise hashCode et
}
equals pour vérifier si un élément existe.
@Override
public boolean equals(Object o) { • Il faut donc redéfinir ces deux méthodes dans la classe
return (this == o) || (o instanceof Personne p &&
age == [Link] && [Link]([Link])); Personne.
}
@Override • hashCode() : permet de localiser rapidement
public int hashCode() { l’élément dans la table de Hachage.
return [Link]([Link], [Link]);
} • equals(Object O) : permet de vérifier l’égalité
}
Deux personnes sont identiques si elles ont entre entre deux éléments.
même nom et même âge

24
HASHSET : equals et hashcode
import [Link];
import [Link];

public class TestHashSet {

public static void main(String[] args) {

Set<Personne> pers = new HashSet<>();
[Link](new Personne("Alia", 25));
[Link](new Personne("Alia", 25)); //ignoré, car même nom et même age
[Link](new Personne("Alia", 21)); //Accepté, car âge différent
for(Personne p : pers)
[Link](p);
}

25
HashSet => Ordre aléatoire
 TREESET
• Un TreeSet peut être créé en utilisant :
11. Un constructeur sans argument, créant un ensemble vide.

Set<Integer> set = new TreeSet<>(); Ordre naturel

21. Un constructeur avec un comparateur spécifique qui définit un ordre personnalisé pour le tri des

éléments.

Set<Integer> set1 = new TreeSet<>([Link]()); Ordre naturel inversé

31. Toute autre collection (par exemple, une List) pour initialiser cet ensemble avec des valeurs initiales.

Set<Integer> set3 = new TreeSet<>([Link](1,2,3));

26
 TREESET : comparable<T>
[Link].*
Comparable<T> est une interface prédéfinie qui permet de définir un
public class Personne implements Comparable<Personne>{
ordre naturel grâce à la méthode compareTo.
private String nom;
private int age; • Un TreeSet trie automatiquement ses éléments à l’insertion,
…
selon l’ordre naturel défini par la méthode compareTo.
@Override
• La classe Personne doit donc implémenter l’interface
public int compareTo(Personne autre) {
int result = [Link]([Link]); Comparable et redéfinir compareTo pour définir cet ordre
if (result == 0) {
return [Link]([Link], [Link]); naturel.
}
return result; • La méthode CompareTo compare deux personnes. Elle
} Le tri se fait d’abord par nom, puis par âge indique si deux personnes sont considérées identiques
} si les noms sont identiques.
et détermine leur ordre à l’insertion.

• C’est préférable d’utiliser les méthodes compareTo() (ou compare) des types des attributs plutôt que de faire des comparaisons
manuelles. 27
 TREESET : comparable<T>
• Si les éléments du TreeSet sont des objets d’une classe que vous avez créée, ces objets doivent
être comparables. La classe doit donc définir un ordre naturel en implémentant l’interface
Comparable, et redéfinir la méthode compareTo(). Cette méthode :
• Prend un seul paramètre
• Retourne :
• Un nombre négatif si l’objet courant est plus petit
• 0 s’ils sont égaux
• Un nombre positif sinon

28
 TREESET : comparable<T>
import [Link];
import [Link];

public class TestTreeSet { Un TreeSet trie ses éléments !

public static void main(String[] args) { La méthode add utilise la méthode compareTo
Set<Personne> pers = new TreeSet<>(); // ordre naturel pour comparer les personnes. Ainsi, le tri sera
[Link](new Personne("Alia", 25)); automatiquement effectué par nom puis par âge,
[Link](new Personne("Alia", 25)); //doublon détecté car c’est ce que définit compareTo.
[Link](new Personne("Alia", 21)); //Accepté
[Link](p -> [Link](p));
}

29
 TREESET : Comparator<T>
• Pour que le TreeSet utilise un ordre différent de l’ordre naturel, il faut lui fournir un comparateur d’objets qui
définit le critère de comparaison, en le passant en argument au constructeur du TreeSet.

Set<Personne> pers = new TreeSet<>(new ComparateurParNom());

On précise le comparateur qui définit l’ordre personnalisé

• Pour créer un comparateur d’objets, on Le type paramètre T sera remplacé
par le type des objets à comparer.
peut définit une classe qui implémente import [Link];
class NomComparateur implements Comparator<T> {
l’interface Comparator<T> et redéfinir la
@Override
méthode compare(). public int compare(T p1, T p2) {
…………
Toute classe qui souhaite définir une règle de }
comparaison externe avec la méthode compare() doit }
implémenter Comparator<T>

30
 TREESET : Comparator<T>
• On crée la classe ComparateurParNom pour comparer les personnes selon leur nom.

import [Link]; On compare des personnes

• On définit le critère de comparaison
//Comparator pour trier les personnes par nom
dans la méthode compare(), qui prend
class ComparateurParNom implements Comparator<Personne> {
deux objets en paramètres et retourne :
@Override
• un nombre négatif si le premier
public int compare(Personne p1, Personne p2) {
objet est inférieur. return [Link]().compareTo([Link]());
• 0 s’ils sont égaux }
• un nombre positif . }

• C’est préférable d’utiliser les méthodes compareTo() (ou compare) des types des attributs plutôt que de faire des
comparaisons manuelles.

31
 TREESET : Comparator<T>
Set<Personne> pers = new TreeSet<>(new ComparateurParNom());

public class Personne { On passe le comparateur au TreeSet

private String nom;
private int age;

…
public String getNom() {
return nom; [Link](new Personne("Alia", 25));
}
[Link](new Personne("Ahmed", 25));
public int getAge() {
return age; [Link](p -> [Link](p));
}
}
Tri par nom

• Le TreeSet utilisera l’ordre personnalisé défini par le comparateur et lors de l’insertion, la méthode add()
utilisera la méthode compare du comparateur. 32
 TREESET : Comparator<T>
• La méthode statique [Link](...) permet aussi de créer un comparateur qui indique un critère de tri
basé sur un attribut spécifique d’un objet.

Set<Personne> pers = new TreeSet<>([Link](Personne::getNom));

public class Personne {

private String nom; comparaison par nom
private int age;
[Link](new Personne("Alia", 25));
…
public String getNom() { [Link](new Personne("Alia", 25)); //doublon ignoré
return nom;
[Link](new Personne("Alia", 21)); //doublon ignore
}
public int getAge() { [Link](p -> [Link](p));
return age;
}
}

33
 TREESET : Comparator<T>
Set<Personne> pers = new TreeSet<>([Link](Personne::getAge));

public class Personne {

private String nom; Comparaison par âge
private int age;

… [Link](new Personne("Alia", 25));

public String getNom() {
[Link](new Personne("Ahmed", 25)); //ignore, même âge
return nom;
} [Link](new Personne("Alia", 21)); //Accepté
public int getAge() {
[Link](p -> [Link](p));
return age;
}
}

34
 TREESET : Comparator<T>
On peut inverser l’ordre du comparateur avec la méthode reversed()

Set<Personne> pers = new TreeSet<>([Link](Personne::getNom).reversed());

public class Personne {

private String nom;
private int age; [Link](new Personne("Alia", 25));
[Link](new Personne("Ahmed", 25));
public Personne(String nom, int age) {
[Link] = nom; [Link](new Personne("Naser", 21));
[Link] = age; [Link](p -> [Link](p));
}
public String getNom() {
return nom;
}
public int getAge() {
return age;
}
}

35
 TREESET : Comparator<T>
• On peut ajouter un second critère de tri en cas d’égalité sur le premier à l’aide de la méthode thenComparing(...)

Set<Personne> pers = new TreeSet<>([Link](Personne::getNom).thenComparing(Personne::getAge));

public class Personne { S’ils ont même nom, on compare l’âge

private String nom;
private int age;
[Link](new Personne("Alia", 25));
… [Link](new Personne("Ahmed", 25));
public String getNom() {
return nom; [Link](new Personne("Alia", 21));
} [Link](p -> [Link](p));
public int getAge() {
return age;
}
}

36
 TRIER UNE COLLECTION
• Si l’on veut utiliser la méthode [Link]() pour trier une collection qui ne trie pas
automatiquement ses éléments (comme une liste), les objets contenus dans cette collection
doivent être comparables :
• Soit via l’ordre naturel (Comparable),
• Soit en précisant un ordre personnalisé via un objet Comparator.

public static void main(String[] args) {

List<Personne> groupe = new ArrayList<>();

[Link](new Personne("Alia", 25));
[Link](new Personne("Mohamed", 24)
[Link]("Tri naturel (par nom et age) :");
[Link](groupe);
[Link]("Tri personnalisé par nom:");
[Link](groupe, new ComparateurParNom());

37
COLLECTIONS : MAP
 L’INTERFACE MAP
• Map <K, V> : On utilise une Map lorsque l'on souhaite identifier une valeur à l'aide d'une clé.
• Lorsque vous utilisez le répertoire de contacts dans votre téléphone, vous cherchez le nom du contact (ex.
"Ahmed") plutôt que de parcourir chaque numéro de téléphone un par un.
(nom du contact, numéro de téléphone)
• Lorsque vous utilisez un dictionnaire, vous cherchez le mot (ex. "arbre") pour identifier sa définition.
(mot, définition)
• Une Map stocke donc des paires clé-valeur => ( K: key, V: value)
• Les clés sont uniques, mais les valeurs peuvent être dupliquées.
• Une Map est une composition d'un ensemble (Set) de clés et d'une collection (Collection) de valeurs.

39
 MAP
• La méthode statique [Link](…) permet d’initialiser une map non modifiable par des
paires ( clé, valeur).

Map<String,String> animaux = [Link](

[Link]("Koala", "bamboo"),
[Link]("Lion", "viande"),
[Link]("Giraffe", "Feuilles")
);

• La méthode statique [Link](…) crée une copie non modifiable d’une Map existante.

Map<String,String> zoo = [Link](animaux);

40
 MAP
• L’interface Map fournit des méthodes spécifiques pour manipuler à la fois les clés et les valeurs.
• V put(K key, V value) : Ajoute ou remplace une paire clé/valeur. Retourne la valeur précédente ou null.
• V putIfAbsent(K key, V value): Ajoute la paire clé/valeur si la clé n’existe pas . Sinon, retourne la valeur existante.

• V get(Object key) : Retourne la valeur associée à la clé, ou null si aucune valeur n’est associée.

• boolean containsKey(Object key) : Vérifie si la clé est présente dans une map.

• boolean containsValue(Object value) : Vérifie si la valeur est présente dans une map.

• V remove(Object key) : supprime la paire clé/valeur et retourne la valeur associée à la clé. Retourne null sinon.

• V replace(K key, V value): Remplace la valeur associée à la clé donnée si la clé est présente. Retourne l'ancienne valeur ou

null sinon.
• Set<K> keySet(): Retourne l'ensemble de toutes les clés.

• Collection<V> values() : Retourne une collection de toutes les valeurs.

• Set<[Link]<K,V>> entrySet(): Retourne un ensemble de paires clé/valeur.

41
 MAP
Map<String,String> animaux = [Link](
[Link]("koala", "bamboo"),
[Link]("lion", "viande"),
public static void main(String[] args) {
… [Link]("giraffe", "feuilles")
Map<String,String> zoo = [Link](animaux); );

[Link]([Link]("lion")); // true
[Link]([Link]("lion")); // false
[Link]([Link]()); // 3
[Link] ([Link]("koala")); // bamboo
[Link] ([Link]("singe")); // null
// Affichage avec forEach koala : bamboo
[Link]((k,v) -> [Link](k + ":" + v)); girafe : feuilles
} lion : viande
42
 IMPLÉMENTATIONS DU MAP

• HashMap, LinkedHashMap et TreeMap sont les trois classes qui implémentent l'interface Map.

Implémentation Stockage des éléments Caractéristiques Quand l’utiliser ?

HashMap<K, V> Table de hachage Rapide mais ordre arbitraire, Stockage rapide de clé-
utilisant le hashCode() de la clé. valeur
TreeMap<K, V> Arbre binaire Clés triées, Avoir un ordre sur les clés
ordre des clés
LinkedHashMap<K, V> HashMap + liste chaînée Ordre d’insertion conservé Parcours dans l’ordre
d’insertion

43
 IMPLÉMENTATIONS DU MAP
static void ajouterAnimaux(Map<String, String> zoo) {
[Link]("koala", "bamboo");
[Link]("lion", "viande");
[Link]("giraffe", "feuilles");
for (String key : [Link]()) [Link]() : retourne l’ensemble
des clés du map
[Link](key + ', ');
}

public static void main(String[] args) {

Ordre aléatoire ajouterAnimaux(new HashMap<>()); // koala, giraffe, lion,
Ordre d’insertion ajouterAnimaux(new LinkedHashMap<>()); // koala, lion, giraffe,
Ordre des clés ajouterAnimaux(new TreeMap<>()); // giraffe, koala, lion,
}

44
IMPLÉMENTATIONS DU MAP
public static void main(String[] args) {

Map<String,String> zoo = new HashMap<>();

[Link]("koala", "bamboo");
[Link]("lion", "viande");
[Link]("giraffe", "feuilles");
[Link]([Link]("lion"," poulet ")); // viande
[Link]([Link]("koala","banane")); // bamboo
[Link]([Link]("lion")); // poulet
[Link]((k,v) -> [Link](k + ":" + v));
koala:bamboo

[Link](); // vider zoo giraffe:feuilles

[Link]([Link]()); // true
}

45
IMPLÉMENTATIONS DU MAP
public static void main(String[] args) {
Map<String, Double> notes = new HashMap<>();
[Link]("E100", 12.5);
14.5
[Link]("E200", 16.0);
[Link]("E300", 10.0); 18.0
//parcourir les clés
for (String matricule : [Link]()) 12.0
[Link](matricule, [Link](matricule) + 2);
//parcourir les valeurs E100 : 14.5
for (Double note : [Link]())
E200 : 18.0
[Link](note);
//parcourir les paires (Key, value)
E300 : 12.0
for ([Link]<String, Double> e : [Link]()) {
[Link]([Link]() + " : " + [Link]());

}
}
46
 TREEMAP : ORDRE ET TRI
• Une TreeMap trie automatiquement les entrées en fonction de leurs clés.

• Lorsque les clés sont des objets d’une classe que vous avez créée, ces clés doivent être

comparables pour que la TreeMap puisse les ranger dans le bon ordre.

• Si on souhaite un ordre naturel, cette classe peut implémenter l’interface Comparable et

redéfinir la méthode compareTo qui spécifie l’orde naturel.

• Si on souhaite un ordre différent de celui défini par compareTo , on peut alors fournir un

Comparator personnalisé à la TreeMap exactement comme on le fait avec le TreeSet.

47
TREEMAP : ORDRE ET TRI
public class Colis implements Comparable<Colis> {
int numero;
double poids;
public Colis(int numero, double poids) {
[Link] = numero;
[Link] = poids;
}
@Override
public int compareTo(Colis autre) {
// Ordre naturel par numéro (ordre croissant)
return [Link]([Link], [Link]);
}
public double getPoids() {
return poids;
}
@Override
public String toString() {
return "Colis{" + "n°=" + numero + ", poids=" + poids + '}';

}
}
48
TREEMAP : ORDRE ET TRI
public static void main(String[] args) {

TreeMap<Colis, String> expeditions = new TreeMap<>(); // tri selon l’ordre naturel

// les colis seront triés par numéro

[Link](new Colis(102, 4.2), "Tanger");
[Link](new Colis(100, 2.5), "Casa");
[Link](new Colis(105, 3.8), "Rabat");

[Link]((k,v)-> [Link] (k + "->" + v));

Colis{ n°= 100, poids= 2.5 } -> Casa

Colis{ n°= 102, poids= 4.2 } -> Tanger
Colis{ n°= 105, poids= 3.8 } -> Rabat
49
TREEMAP : ORDRE ET TRI

//Comparator pour trier les colis par poids

class ComparateurParPoids implements Comparator<Colis> {
@Override
public int compare(Colis c1, Colis c2) {
return [Link]([Link](), [Link]());
}
}

50
TREEMAP : ORDRE ET TRI
public static void main(String[] args) {

TreeMap<Colis, String> expeditions = new TreeMap<>(new ComparateurParPoids());

// les colis seront triés par poids

[Link](new Colis(102, 4.2), "Tanger");

[Link](new Colis(100, 2.5), "Casa");
[Link](new Colis(105, 3.8), "Rabat");

[Link]((k,v)-> [Link] (k + "->" + v));

Colis{ n°= 100, poids= 2.5 } -> Casa

Colis{ n°= 105, poids= 3.8 } -> Rabat
Colis{ n°= 102, poids= 4.2 } -> Tanger
51