Le document présente les collections en Java, incluant les interfaces principales comme Collection et Map, et leurs implémentations telles qu'ArrayList, LinkedList, HashSet et TreeSet. Il explique les méthodes associées à ces collections, y compris les opérations d'ajout, de suppression et d'accès, ainsi que les concepts d'autoboxing et d'unboxing. Enfin, il fournit des exemples de code pour illustrer l'utilisation de ces structures de données.

1. Java/Collections
Pr Abderrahim Marzouk
Département de Mathématiques et
Informatique
Licence BIG DATA 2019-2020
1

2. Collection ?
Une collection est un objet qui permet de gérer un
ensemble d'objets. Cet ensemble peut: contenir
des doublons, être ordonné, etc. ...
L'API Collections possède deux grandes familles de
collections chacune définie par une interface :
• java.util.Collection : pour gérer un ensemble
d'objets
• java.util.Map : pour gérer des paires (clé,valeur)
2

3. Collection<E>
3
où: E spécifie le type classe des éléments de la collection.

4. Collection<E>:méthodes communes
boolean add(Object): ajouter un élément
boolean addAll(Collection): ajouter plusieurs éléments
void clear(): tout supprimer
boolean contains(Object): test d'appartenance
boolean containsAll(Collection): appartenance collective
boolean isEmpty(): test de l'absence d'éléments
Iterator iterator(): pour le parcours (cf Iterator)
boolean remove(Object): retrait d'un élément
boolean removeAll(Collection): retrait de plusieurs éléments
boolean retainAll(Collection): intersection
int size(): nombre d'éléments
Object[] toArray(): transformation en tableau
Object[] toArray(Object[] a): tableau de même type que le tableau a
4

5. List<E> et Set<E>
• List: interface qui représente une collection d'éléments ordonnés
qui accepte les doublons
• Set: interface qui représente une collection d'éléments non
ordonnés par défaut qui n'accepte pas les doublons
5

6. List<E> et Set<E>
// Déclaration de List<E>
public interface List<E> extends Collection<E>{
}
// Déclaration de Set<E>
public interface Set<E> extends Collection<E>{
}
6

7. ArrayList : tableaux dynamiques
ArrayList est l'implémentation de l’interface List
où les éléments peuvent être ajoutés ou
supprimés dynamiquement de la liste. De plus,
la taille de la liste est augmentée
dynamiquement si les éléments sont ajoutés
plus que la taille initiale.
Dynamique = la taille (nombres d’éléments) du
tableau n’est pas fixe et peut varier en cours
d’exécution
7

8. Exemple: ArrayList
List<String> mois=new ArrayList<String>();
mois.add("Janvier");
mois.add("Fevrier");
mois.add("Mars");
for(int i=0; i<mois.size();i++)
System.out.println(mois.get(i));
// ou
for(String m:mois)
System.out.println(m);
8
Les deux boucles affichent:
Janvier
Fevrier
Mars

9. LinkedList: listes doublement chaînées
La classe LinkedList implémente l’interface List:
elle implémente les listes doublement chaînées
9
Méthodes supplémentaires:
addFirst(Object o) : ajoute l’élémént o au début de la liste
addLast(Object o) : ajoute l’élémént o à la fin de la liste
Object getFirst() : retourne le premier élémént de la liste
Object getLast() : retourne le dernier élément de la liste
Object removeFirst(): supprime et retourne le premier élément de la liste
Object removeLast() : supprime et retourne le dernier élément de la liste

10. LinkedList: listes doublement chaînées
• LinkedList fournit une liste doublement
chaînée. L'ajout d'un élément est rapide, mais
la recherche d'une valeur donnée et l'accès au
ième élément sont en O(n).
• ArrayList est une implémentation à base de
tableau. L'ajout d'un élément peut être plus
coûteux que dans le cas d'une LinkedList si le
tableau doit grossir, mais par contre l'accès au
ième élément est en temps constant.
10

11. Exemple: LinkedList
LinkedList<String> mois=new LinkedList<String>();
mois.add("Janvier");
mois.add("Fevrier");
mois.add("Mars");
for(int i=0; i<mois.size();i++)
System.out.println(mois.get(i));
// ou
for(String m:mois)
System.out.println(m);
System.out.println(mois.getFirst());//Janvier
System.out.println(mois.getLast());//Mars
11

12. HashSet
La classe Java HashSet implémente l'interface
Set. Elle contient des éléments uniques. Elle
permet un accès très performant aux éléments
12

13. Exemple: HashSet
Set<Integer> entiers= new HashSet();
entiers.add(2);
entiers.add(3);
entiers.add(5);
entiers.add(7);
entiers.add(2);//2 ne sera pas ajouté:
Set n'accepte pas les doublons
// int x= entiers.get(4);//La méthode
get() n'est pas défini dans Set
for(Integer i: entiers)
System.out.println(i);
13
Le programme affiche:
2
3
5
7

14. TreeSet
La classe TreeSet implémente l'interface Set. Elle
maintient l'ensemble trié en permanence.
Si les objets de TreeSet ne peuvent pas être triés
selon l’ordre naturel, on peut utiliser
un Comparator ou Comparable pour définir l’ordre
dans lequel les éléments sont organisés dans
la Map.
les temps d'accès et de récupération sont plus
rapides.
14

15. TreeSet
Méthodes supplémentaires
first(): retourne le premier élément d’un TreeSet s’il n’est pas
vide. Sinon, il lève une NoSuchElementException.
last():retourne le dernier élément si l’ensemble n’est pas vide
subSet(debut,fin): renvoit les éléments allant
de debut à fin. Notez que debut est inclusif et fin est exclusive.
headSet(fin): retourne les éléments de TreeSet qui sont plus
petits que l’élément fin
tailSet(debut): renvoit les éléments d’un TreeSet qui sont
supérieurs ou égaux à l’élément debut
15

16. Exemple 1: TreeSet
TreeSet<String> fruits = new TreeSet<>();
fruits.add("Orange");
fruits.add("Banane");
fruits.add("Pomme");
fruits.add("Abricot");
fruits.add("Fraise");
System.out.println(fruits);
System.out.println(fruits.first());
System.out.println(fruits.last());
16
Le programme affiche:
[Abricot, Banane, Fraise,
Orange, Pomme]
Abricot
Pomme
Les fruits sont affichés par
ordre alphabétique

17. Exemple 2: TreeSet
SortedSet<Integer> treeSet = new TreeSet<>();
treeSet.add(13);
treeSet.add(5);
treeSet.add(7);
treeSet.add(3);
treeSet.add(11);
treeSet.add(2);
System.out.println(treeSet);
System.out.println("---------------------");
Set<Integer> subSet1 = treeSet.subSet(2, 6);
System.out.println(subSet1);
System.out.println("---------------------");
Set<Integer> subSet2 = treeSet.headSet(12);
System.out.println(subSet2);
System.out.println("---------------------");
Set<Integer> subSet3 = treeSet.tailSet(3);
System.out.println(subSet3);
17
Le programme affiche:
[2, 3, 5, 7, 11, 13]
---------------------
[2, 3, 5]
---------------------
[2, 3, 5, 7, 11]
---------------------
[3, 5, 7, 11, 13]

18. Map<K,V>
18
où:
K : spécifie le type classe de clés.
V : définit le type classe de valeurs.

19. Map<K,V>
Map = ensemble de paires (clé, valeur)
Map aussi appelée tableau associatif ou encore
dictionnaire
Rappel: les collections de type Map, sont définies à partir de
la racine Interface Map<K, V> ( et non Collection<E> )
19

20. Map<K,V>: principales méthodes
void clear(): vider la collection.
boolean containsKey(Object key): teste si la clé existe.
boolean containsValue(Object value): teste si la valeur existe.
Set entrySet() : retourne l'ensemble des associations clés-valeurs.
Set keySet() : retourne l'ensemble des clés.
Collection values() : retourne la collection de valeurs.
Object put(Object key, Object value): associe la clé à la valeur spécifiée, et retourne
la valeur précédemment associée.
boolean putAll(Map m) : ajouter tous les objets d'une autre collection à celle-ci.
Object get(Object key) : retourne la valeur associée à la clé spécifiée, ou null sinon
trouvé.
Object remove(Object key): supprime l'objet associé à la clé, et retourne cet objet.
boolean isEmpty(): tester si la collection est vide.
int size() : retourne le nombre de clés.
20

21. HashMap<K,V>
La classe HashMap implémente l'interface Map, et permet
d'utiliser la clé null.
Map<String,String> map=new HashMap<>();
map.put("Maroc", "Rabat");
map.put("France", "Paris");
int nbPaires =map.size();
for (String pays : map.keySet())
{ String capitale = map.get(key);}
21

22. HashMap<K,V>
for (Map.Entry<String, String> entry :
map.entrySet()) { String pays = entry.getKey();
String capitale= entry.getValue();
// ... }
22

23. Exemple : HashMap
Map<String, Integer> voitures = new HashMap<>();
voitures.put("BMW", 5);
voitures.put("Mercedes", 3);
voitures.put("Audi", 4);
voitures.put("Ford", 10);
System.out.println("Total voitures: " + voitures.size());
for (String key : voitures.keySet())
System.out.println(key + " - " + voitures.get(key));
System.out.println();
voitures.clear();
System.out.println("Apres la méthode clear, size: " +
voitures.size());
23
Le programme affiche:
Total voitures: 4
Audi - 4
Ford - 10
Mercedes - 3
BMW - 5
Apres la méthode clear, size:
0

24. TreeMap<K,V>
La classe TreeMap implémente l'interface Map. Elle
conserve ses entrées triées selon l’ordre naturel de ses
clés ou mieux encore à l’aide d’un comparateur si
fourni par l’utilisateur au moment de la construction.
Si les objets TreeMap ne peuvent pas être triés selon
l’ordre naturel, nous pouvons utiliser
un Comparator ou Comparable pour définir l’ordre
dans lequel les éléments sont organisés dans la Map:
24

25. Exemple : TreeMap
Map<String, Integer> voitures = new TreeMap<>();
voitures.put("BMW", 5);
voitures.put("Mercedes", 3);
voitures.put("Audi", 4);
voitures.put("Ford", 10);
System.out.println("Total voitures: " + voitures.size());
for (String key : voitures.keySet())
System.out.println(key + " - " + voitures.get(key));
System.out.println();
System.out.println("La plus grande cle: " + ((TreeMap)
voitures).lastKey());
System.out.println("La plus petite cle: " + ((TreeMap)
voitures).firstKey());
25
Le programme affiche:
Total voitures: 4
Audi - 4
BMW - 5
Ford - 10
Mercedes - 3
La plus grande cle: Mercedes
La plus petite cle: Audi
Comme vous pouvez le
constater, les éléments de la
map sont affichés dans un
ordre lexicographique strict,
ce qui n'apparaît pas dans
l’exemple précédent
de HashMap

26. Autoboxing et Unboxing
Autoboxing: La conversion automatique des types primitifs en
l'objet de leurs classes wrapper correspondantes.
Par exemple - conversion de int en Integer, long en Long, double
en Double, float en Float, etc.
Integer i = 3; // int -> Integer
Long l = 3L; // long -> Long
Long l = 3; // erreur, int -> Integer -X-> Long
26
Auto-unboxing
Integer i = new Integer(3);
int x = i; // Integer -> int

27. Autoboxing et Unboxing
List<Integer> arrayList = new ArrayList<>();
// Autoboxing car ArrayList stockent uniquement des objets
arrayList.add(25);
// afficher la valeur de l’objet
System.out.println(arrayList.get(0));
27
List<int> ne compile pas, car le type des éléments d’une collection doit être une
classe et non un type primitif. Utilisez à la place List<Integer>

28. Autoboxing et Unboxing
Dans l'exemple ci-dessus, nous avons créé une
liste d'éléments de type Integer. Nous ajoutons
des valeurs de type primitif int au lieu de l'objet
Integer et le code a été compilé avec succès. Il
ne génère pas d'erreur de temps de compilation
car le compilateur Java crée un objet wrapper
Integer à partir de la primitive int i et l'ajoute à
la liste.
28

29. A Consulter
https://www.w3resource.com/java-
exercises/collection/index.php#arraylist
29