For Java developpers

1. Les collections
Java.util
Youness IDRISSI KHAMLICHI
ENSA-Fès
1

2. Les collections en Java
À quoi servent les collections ?
 Stocker les données
 Autrement que dans de simples tableaux
des structures de tailles dynamique
des structures adaptées au besoin
 Sans réinventer la roue
 Gagner du temps et de l’énergie
 Bénéficier de classes robustes et performantes
 Fournies par Java en standard
 Dans le package java.util
Plus de détails, plus de documentation, visitez les sites ci-dessous :
https://docs.oracle.com/javase/8/docs/api/java/util/package-summary.html
2

3. Le package java.util
3
 Plus de détails, plus de documentation, visitez les sites ci-dessous :
 https://docs.oracle.com/javase/7/docs/api/java/util/package-summary.html
 https://docs.oracle.com/javase/8/docs/api/java/util/package-summary.html
I
I
I
I I I I

4. « List-Set-Map » dans java.util
Map
HashMap HashTable SorteMap
TreeMap
extends
implements
implements
implements
Collection
Set List
ArrayList
extends
implements
extends
HashSet
implements
4

5. Table de comparaison (List-Set-Map)
List Set Map
Duplication
List permet les éléments en
double.N’importe quel
nombre d’éléments en
double peut être inséré
dans la liste sans affecter les
mêmes valeurs existantes et
leurs index.
Set n’autorise pas les
doublons.Set et toutes les
classes qui implémentent
l’interface Set doivent
avoir des éléments
uniques.
Map stocke les éléments sous forme de
paire clé/valeur. Map n’autorise pas les clés
en double, mais les valeurs en double.
Valeurs
nulles
List autorise n’importe quel
nombre de valeurs NULL.
Set autorise au plus une
valeur NULL unique.
Map peut avoir au plus une clé NULL
unique et un nombre quelconque de valeurs
NULL.
Ordre
List et toutes ses classes
d’implémentation
conservent l’ordre
d’insertion.
Set ne maintient aucun
ordre; encore peu de ses
classes trient les éléments
dans un ordre tel que
LinkedHashSet conserve
les éléments dans l’ordre
d’insertion.
Pareil à Set, Map ne stocke pas non plus les
éléments dans un ordre, mais peu de ses
classes font de même. Par exempleTreeMap
trie la map dans l’ordre croissant des clés et
LinkedHashMap trie les éléments dans
l’ordre d’insertion, l’ordre dans lequel ils
ont été ajoutés à LinkedHashMap.
Les classes
utilisés
ArrayList, LinkedList etc.
HashSet,LinkedHashSet,
TreeSet,SortedSet etc.
HashMap,TreeMap,WeakHashMap,
LinkedHashMap,IdentityHashMap,etc.
5

6. L’interface Collection
 Principales méthodes
 int size()
 boolean isEmpty
 boolean add(Object o)
 boolean remove(Object o)
 boolean contains(Object o)
 void clear()
 Iterator iterator()
 Exemples de classes l’implémentant
 ArrayList, LinkedList : différents types de liste
 TreeSet, HashSet : différents types d’ensemble
6

7. L’interface Iterator
 Spécifie les caractéristiques d’un « itérateur »
 Énumère les éléments d’une collection
 Pour écrire une itération
 Parcours dans un seul sens
 Disponible pour toute collection
 Via la méthode iterator() imposée par l’interface Collection
 Principales méthodes d’un itérateur
 Boolean hasNext()
 Object next() throws NoSuchElementException
 L’exception (éventuellement) lancée dérive de
RuntimeException
7
public interface Iterable<T> {
Iterator<T> iterator();
}

8. Utilisation d’itérateur
 Exécution :
// Exemple de parcours d'une collection
public static void main(String[] args) {
Collection collection = new HashSet();
collection.add("un");
collection.add("deux");
collection.add("trois");
Iterator it = collection.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
8

9. Utilisation implicite d’itérateur
 Utilisation du « for each »
 Fonctionne pour tous les objets implémentant l’interface
Iterable (en particulier les collections)
Collection collection = new HashSet();
collection.add("un");
collection.add("deux");
collection.add("trois");
//Iterator it = collection.iterator();
for (Object o : collection) { //foreach
System.out.println(o.getClass() + " - " + o);
}
9

10. L’interface List
 Spécifie les caractéristiques d’une liste
 Suite de données ordonnées (et indexées à partir de 0)
 Pouvant contenir des doublons
 Principales méthodes (en + de celles imposées par
Collection)
 void add(int index, Object o)
 Object get(int index)
 Object remove(int index)
 Int indexOf(Object o)
 Exemple de classes l’implémentant
 ArrayList : liste dans un tableau, accès rapide
 LinkedList : liste chaînée, insertion rapide
10

11. L’interface List : Exemple (1/2)
//Une Liste de collection du type String
List<String> myArray = new ArrayList<String>();
myArray.add("un");
myArray.add("deux");
myArray.add("trois");
for (int i = 0; i < myArray.size(); i++) {
System.out.println(myArray.get(i));
}
Résultat :
un
deux
trois
11

12. L’interface List : Exemple (2/2)
List<String> list = new ArrayList<>();
// ou List list = new LinkedList();
list.add(0, "Dimanche");
list.add(1, "Lundi");
list.add(2, "Mardi");
list.add(3, "Mercredi");
list.add(4, "Jeudi");
list.add(5, "Vendredi");
list.add(6, "Samedi");
(2)
// foreach
for (Object o : list) {
System.out.println(o);
}
(1)
Iterator it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
12

13. L’interface set
 Spécifie les caractéristiques d’un ensemble
 Ensemble de données non ordonnées
 Sans doublons
 Principales méthodes
 Celles de collection
 Exemples de classes l’implémentant
 HashSet : temps constant pour les opérations de base
 TreeSet : éléments rangés selon leur ordre naturel
13

14. L’interface Map
 Spécifie les caractéristiques d’un « dictionnaire »
 Ensemble de couples (clé, valeur)
 Clés uniques, Couples non ordonnés
 Principales méthodes
 Object put(Object key, Object value)
 boolean containsKey(Object key)
 Object get(Object key)
 Set keySet()
 Collection values()
 Exemples de classes l’implémentant
 HashMap, TreeMap
14

15. L’interface Map : exemple
Map map = new HashMap();
map.put("OS", "Windows");
map.put("langage1", "Java");
map.put("langage2", "Java ee");
map.put("langage3", "Android");
map.put(null, null);
Set set = map.keySet(); //keyset retourne les clés
(2)
Iterator it = set.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
(1)
for (Object o : set) {
System.out.println(o);
}
Résultat :
15

16. Algorithmes fournis
 D’autres algorithmes de la classe Collections
 min(l), max(l), sort(l), reverse(l), shuffle(l) …
List list = new LinkedList();
list.add(0, "Dimanche");
list.add(1, "Lundi");
list.add(2, "Mardi");
list.add(3, "Mercredi");
list.add(4, "Jeudi");
list.add(5, "Vendredi");
list.add(6, "Samedi");
//Recherche dans une liste
int index = Collections.binarySearch(list, "Vendredi");
System.out.println("Index = " + index);
16

17. Exemple : tri d’une liste
List l = new ArrayList();
l.add(2);
l.add(3);
l.add(1);
for (Object o : l) {
System.out.println(o);
}
Collections.sort(l);
for (Object o : l) {
System.out.println(o);
}
17

18. Opérations dans une collection ArrayList
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("Dimanche");
arrayList.add("Lundi");
arrayList.add("Mardi");
//Trouver l’indice d’une vlaur dans un ArrayList
System.out.println(arrayList.indexOf("Mardi"));
//true si la valeur existe
System.out.println(arrayList.contains("Mardi"));
// Remplacer Lundi par Bonjour
System.out.println(arrayList.set(1, "Bonjour"));
//Retourner false, la valeur Lundi n'existe plus
System.out.println(arrayList.contains("Lundi"));
18

19. Opérations dans une collection HashMap
HashMap<String, String> hashMap = new HashMap<>();
hashMap.put("nom", "IDRISSI");
hashMap.put("prenom", "Youness");
hashMap.put("fonction", "Professeur d'Enseignement Seuperieur");
hashMap.put("ville", "Fès");
//Trouver un objet par clé dans un HashMap
System.out.println(hashMap.get("nom"));
//true si la valeur existe
System.out.println(hashMap.containsValue("Fès"));
//true si la clé existe
System.out.println(hashMap.containsKey("ville"));
//Supprimer une clé
hashMap.remove("ville");
//retourner false après supression
System.out.println(hashMap.containsValue("Fès"));
19

20. Stack vs Queue
20
 Stack : LIFO
 Queue : FIFO
 [1, 2, 3]
 Queue (qu.poll();) => [2, 3]
 Stack (stack.pop();) => [1, 2]
queue.offer(el);
stack.push(el);
queue.poll();
stack.pop();

21. Stack vs Queue
21
Queue<Integer> qu = new PriorityQueue<Integer>();
qu.offer(1);
qu.offer(2);
qu.offer(3);
System.out.println(qu);
qu.poll(); System.out.println("Queue => " + qu);
qu.poll(); System.out.println("Queue => " + qu);
qu.poll(); System.out.println("Queue => " + qu);
Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack);
stack.pop(); System.out.println("Stack => " + stack);
stack.pop(); System.out.println("Stack => " + stack);
stack.pop(); System.out.println("Stack => " + stack);
Résultat :
[1, 2, 3]
Queue => [2, 3]
Queue => [3]
Queue => []
[1, 2, 3]
Stack => [1, 2]
Stack => [1]
Stack => []