Chapitre8: Collections et Enumerations En Java

1
Programmation Orientée Objet
(Java 13 )
Aziz DAROUICHI
FST-UCA
Mail to : pr.azizdarouichi@gmail.com

2
Notion de Collection
Généricité
Interface Collection
Parcourir les collections
Interface Iterator
Interface ListIterator
Classe Collections
Interface List<E>
Classes ArrayList<E>, LinkedList<E>
Classes Vector<E>, Stack<E>
Interface Set<E>
Interface SortedSet<E>
Interface NavigableSet<E>
Interface Map<K,V>
Interface Queue
Les Enumérations
Généricité
Interface Iterator
Classe Collections
Interface List<E>
Classes ArrayList<E>, LinkedList<E>
Classes Vector<E>, Stack<E>
Interface Set<E>
Interface Map<K,V>
Interface Queue
Les Enumérations
Chapitre 7: Les collections & les Enumérations

Une collection d’objets est juste un ensemble regroupant de
multiples objets en une seule unité.
Le JDK fournit d’autres types de collections sous la forme de
classes et d’interfaces.
Ces classes et interfaces sont dans le package java.util.
Exemples:
collection de joueurs
collection d’objets d’art
Les tableaux Array sont des exemples d’implémentation d’une
collection.
La classe ArrayList en est une autre.
3

4
Classes permettant de manipuler les principales structures de données
Vecteurs dynamiques implémentés par ArrayList et Vector
Ensemble par HashSet et TreeSet
Listes chaînées par LinkedList
Tables associatives par HashMap et TreeMap
Toutes ces classes implémentent l’interface Collection qu’elles
complètent de fonctionnalités propres.

Généricité
5
Les collections en Java sont génériques
Peuvent contenir des éléments de types quelconque pour peu qu’ils
s’agissent d’objets.

6
Hiérarchie d’Interfaces:

Ordre des éléments d’une collection
Certaines en sont dépourvus (i.e. ensemble) d’un quelconque
ordonnancement de leurs éléments.
D’autres en possèdent un: vecteurs dynamiques ou listes chaînées
Les éléments sont naturellement ordonnés suivant l’ordre dans
lequel ils ont été disposés.
7

Méthode compareTo() de l’interface Comparable
Certaines classes comme String, classes enveloppes (Integer,
Float,…) implémente l’interface Comparable et dispose donc
d’une méthode compareTo() qui conduit à un ordre naturel
Lexicographique pour les chaînes de caractères, les noms de
fichier ou la classe Character
Numériques pour les classes enveloppes numériques
Pour des objets propres à l’utilisateur: nécessaire de redéfinir la
méthode public int compareTo (E o)
8

Si vos éléments sont des objets d’une classe E que vous êtes
amené à définir, vous pouvez toujours lui faire implémenter
l’interface Comparable<E> et définir la méthode:
public int compareTo (E o)
négatif si l’on considère que l’objet courant est "inférieur" à l’objet o
(au sens de l’ordre qu’on veut définir),
nul si l’on considère que l’objet courant est égal à l’objet o (il n’est ni
inférieur, ni supérieur),
positif si l’on considère que l’objet courant est "supérieur" à l’objet o.
9

Utilisation d’un objet comparateur
Dans quels cas?
Les éléments sont des objets d’une classe existante
n’implémentant pas l’interface Comparable
Besoin de définir plusieurs ordre différents sur une même
collection.
10

Il est alors possible de définir l’ordre souhaité, non plus dans la
classe des éléments mais :
soit lors de la construction de la collection,
soit lors de l’appel d’un algorithme.
11

Pour ce faire, on fournit en argument (du constructeur ou de
l’algorithme) un objet qu’on nomme un comparateur.
Il s’agit en fait d’un objet d’un type implémentant l’interface
Comparator<E> qui comporte une seule méthode :
public int compare(E o1, E o2)
Cette méthode doit donc comparer les objets o1 et o2 reçus en
argument et renvoyer un entier (dont la valeur exacte est sans
importance) :
négatif si l’on considère que o1 est inférieur à o2,
nul si l’on considère que o1 est égal à o2,
positif si l’on considère que o1 est supérieur à o2.
12

Exemple 1/4:
import java.util.*;
public class Chien {
int nombre;
Chien(int i){
nombre = i;
}
void imprimer(){
System.out.println("Chien "+nombre);
}
public String toString(){
return "Chien :"+nombre;
}
}
13

Exemple 2/4:
class ChienComparator implements Comparator{
public int compare(Object o1, Object o2){
if ((((Chien)(o1)).nombre) < (((Chien)(o2)).nombre)) return -1;
else if ((((Chien)(o1)).nombre) > (((Chien)(o2)).nombre)) return 1;
else return 0;
}
}
14

Exemple 3/4:
class MainChien{
public static void main(String[] args) {
ArrayList c = new ArrayList();
Random r = new Random();
for (var i=0; i<10; i++) c.add(new Chien(r.nextInt(100)));
for (var i=0; i<c.size(); i++) System.out.println(i + " " +c.get(i));
Comparator comp = new ChienComparator();
System.out.println("max " + Collections.max(c,comp));
Collections.sort(c,comp);
for(var i=0; i<c.size(); i++)
System.out.println(i + " " + c.get(i));
}
}
15

Exemple 4/4:
16

Exemple 1/3:
import java.util.*;
public class Chienc implements Comparable{
int nombre;
Chienc(int i){
nombre = i;
}
void imprimer(){
System.out.println("Chienc "+nombre);
}
return "Chienc :"+nombre;
}
17

Exemple 2/3:
public int compareTo(Object o) {
if ((this.nombre) < (((Chienc)(o)).nombre))
return -1;
else if ((this.nombre) > (((Chienc)(o)).nombre))
return 1;
else
return 0;
}
}
18

Exemple 3/3:
class MainChienc{
ArrayList c = new ArrayList();
for (var i=0; i<10; i++) c.add(new Chienc(r.nextInt(100)));
for (var i=0; i<c.size(); i++) System.out.println(i + " " +c.get(i));
System.out.println("max " + Collections.max(c));
Collections.sort(c);
for(int i=0; i<c.size(); i++)
System.out.println(i + " " + c.get(i));
}
}
19

Combinaison des deux
Tri sur différents critères
import java.util.*;
class Chien implements Comparable{
int nombre;
int longueur;
Chien(int i, int j){
nombre = i;
longueur = j;
}
20

public int compareTo(Object o) {
if ((this.nombre) < (((Chien)(o)).nombre))
return -1;
else if ((this.nombre) > (((Chien)(o)).nombre))
return 1;
else
return 0;
}
void imprimer(){
System.out.println("Chien "+nombre);
}
return "Chien :"+nombre+":"+longueur;
}
}
21

class ChienComparator implements Comparator{
public int compare (Object o1, Object o2){
if ((((Chien)(o1)).longueur) < (((Chien)(o2)).longueur)) return -1;
else if ((((Chien)(o1)).longueur) > (((Chien)(o2)).longueur)) return 1;
else return 0;
}
}
22

public class MainChien2 {
ArrayList c= new ArrayList();
for (var i=0; i<10; i++) c.add(new Chien(r.nextInt(100), r.nextInt(10)));
System.out.println(i + " " +((Chien) c.get(i)).nombre+":"+((Chien) c.get(i)).longueur);
Comparator comp = new ChienComparator();
System.out.println("max comparateur" + Collections.max(c,comp));
Collections.sort(c,comp);
System.out.println("max comparable" + Collections.max(c));
Collections.sort(c);
}
}
23

Méthodes disponibles
void copy(List, List): copie tous les éléments
size() et isEmpty(): retourne le nombre d'éléments portés par cette collection,
et un booléen qui permet de tester si cette collection est vide ou pas.
add(T t) et remove(T t) : permet d'ajouter (resp. de retirer) un objet à cette
collection.
Object max(Collection): renvoie le plus grand élément de la collection.
Object max(Collection, Comparator): renvoie le plus grand élément de la
collection selon l’ordre précisé par l’objet Comparator.
contains(T t) : renvoie true si l'objet passé en paramètre est contenu dans cette
collection.
void sort(List): trie la liste dans un ordre ascendant.
void sort(List, Comparator): trie la liste dans un ordre ascendant selon
l’ordre précisé par l’objet Comparator.
toArray(T[] a) : convertit la collection courante en tableau.
24

clear() : efface la collection courante.
iterator() : retourne un itérateur sur les éléments de cette collection.
addAll(Collection<? extends T> collection) et removeAll(Collection<?
extends T> collection) : permet d'ajouter (resp. de retirer) l'ensemble des objets
passés dans la collection en paramètre.
retainAll(Collection<? extends T> collection) : permet de retirer tous les
éléments de la collection qui ne se trouvent pas dans la collection passée en paramètre.
Cette opération réalise l'intersection des deux collections.
containsAll(Collection<? extends T> collection) : retourne true si tous les
éléments de la collection passée en paramètre se trouvent dans la collection courante.
Cette opération teste l'inclusion.
…
25

Remarque:
Si la méthode sort(List) est utilisée, il faut obligatoirement que
les éléments inclus dans la liste implémentent tous l’interface
Comparable.
Même chose pour max(Collection).
26

Exemple de tri
import java.util.*;
public class TestTri {
int nb[] = {4,5,2,1,6,8,3};
ArrayList t = new ArrayList();
for (var i=0; i<nb.length; i++) t.add(new Integer(nb[i]));
System.out.println("t initial="+t);
Collections.sort(t);
System.out.println("t trié="+t);
Collections.shuffle(t);
System.out.println("t mélangé="+t);
Collections.sort(t, Collections.reverseOrder()); // un comparateur prédéfini
System.out.println("t trié="+t);
}
}
27

Interface Iterator (Itérateur)
Objet permettant de parcourir un par un (en séquence) les
éléments d’une collection (curseur).
Utile quand les éléments de la collection ne sont pas indexés.
Principales méthodes d’un itérateur Java
28
Méthode Description
boolean hasNext() retourne true s'il reste des éléments à parcourir.
E next() retourne l'élément courant dans l'itérateur. Si vous invoquez cette
méthode plusieurs fois dans une boucle de parcours, cela vous fait
avancer dans la lecture de la collection, un peu comme si vous
incrémentiez plusieurs fois le compteur d'une boucle for.
void remove() supprime le dernier élément renvoyé par l’itérateur.

Interface Iterator (Itérateur)
Deux sortes d’itérateurs
Monodirectionnels: parcours début vers la fin.
Bidirectionnels: parcours peut se faire dans les deux sens.
29

Interface Iterator
Utilisation des plusieurs techniques pour parcourir et afficher les
éléments d’une collection.
Java propose un outil facile et efficace.
Le parcours dans une collection d’objets, s’effectue par
l’intermédiaire d’un objet de type Iterator que l’on applique à la
collection.
30

Interface Iterator
public interface Iterator<E> {
boolean hasNext();
E next();
void remove();
}
31

Itérateur monodirectionnel
Interface Iterator
Chaque classe de l’interface Collection dispose d’une méthode
nommée:
iterator(), i.e. un objet d’une classe implémentant l’interface Iterator.
Remarque:
Un itérateur indique/désigne la position courante.
La méthode next() : retourne l'élément suivant;
La méthode hasNext() : retourne true si la collection possède encore
des éléments à itérer;
La méthode remove() : permet de retirer de la collection l'élément
courant. Cette opération est optionnelle, et peut ne pas être supportée
par toutes les implémentations. Si une implémentation ne supporte
pas cette méthode, alors elle doit jeter
l'exception UnsupportedOperationException.
32

Canevas de parcours d’une collection
Interface Iterator
Boucle while
Parcourir tous les éléments d’une collection c<E> avec un itérateur,
en appliquant le canevas suivant:
Iterator<E> iter = c.iterator();
while (iter.hasNext()) {
E o = iter.next();
//utilisation de o
System.out.println(o);
}
33

Interface Iterator
Boucle for
Parcours d'une liste à l'aide d'un itérateur
List maList =new ArrayList();
…
for (Iterator i = maList.iterator( ); i.hasNext( );)
System.out.println (i.next( )) ;
34

Interface Iterator
Boucle for-each
Parcourir les éléments d'une collection avec un for-each
for (type element : collection) {
System.out.println(element) ;
}
type: type des objets de la collection (par exemple String).
35

Conversion d'une collection en tableau
On peut créer un tableau à partir des éléments contenus dans
une collection.
// pattern de conversion d'une collection en tableau
String [] tab = collection.toArray(new String[] {}) ;
// affichage du contenu du tableau
for (String element : tab) {
System.out.println(element) ;
}
36

Suppression d’un élément dans une collection
Méthode remove() de l’interface Iterator
La méthode remove() supprime de la collection le dernier
objet renvoyé par next().
Voici par exemple comment supprimer d’une collection c tous
les éléments vérifiant une condition :
Iterator<E> iter = c.iterator();
while (iter.hasNext()){
E o = iter.next();
// fournit l’élément désigné par l’itérateur et avance l’itérateur à la position suivante
if (condition) iter.remove();
}
37

Suppression d’un élément dans une collection
Méthode remove()
Remarque:
Pour supprimer un élément de la collection il faut l’avoir lu
auparavant.
38

Itérateurs bidirectionnels
L'interface List supporte bien sûr la méthode iterator(), mais elle ajoute une
autre méthode analogue, listIterator().
La méthode listIterator() retourne un objet de type ListIterator, qui est une
interface, extension de Iterator.
Objet implémentant l’interface ListIterator (dérivée de Iterator)
En plus des méthodes de Iterator
Méthodes duales
previous(): retourne l'élément précédent.
previousIndex() et nextIndex(): retournent respectivement l'index de l'élément
précédent, et l'index de l'élément suivant.
hasPrevious(): retourne un booléen qui est vrai s'il existe un élément à itérer
dans l'ordre décroissant des index.
Méthodes d’addition d’un élément à la position courante (add()) ou de
modification de l’élément courant (set()), de plus la méthode remove() qui
permet de retirer de la liste l'élément que l'on vient d'itérer.
39

Exemple: parcours inversé
ListIterator iter = c.ListIterator(l.size()); // position courante: fin de liste
while (iter.hasPrevious()){
Object o = iter.previous();
}
40

Méthode add()
Interface ListIterator prévoit une méthode add()
add(T t) : permet d'insérer un élément dans la liste à l'endroit où l'on
se trouve, c'est-à-dire avant l'élément qui aurait été retourné par un
appel à next().
Notons que si l'on fait un appel à next() après une telle insertion, ce
n'est pas l'élément que l'on vient d'insérer qui est retourné, mais
l'élément suivant.
ListIterator it = c.listIterator();
it.next(); // premier élément
it.next(); // deuxième élément
it.add(elem); // ajoute elem à la position courante i.e entre le premier et le dernier élément
41

Méthode Set()
Set(elem): remplace par elem l’élément courant i.e. le dernier
renvoyé par next() ou previous().
ListIterator it = c.listIterator();
While (it.hasNext()) {
Object o = it.next();
If (condition) it.set(null);
}// remplace par null tous les éléments d’une collection vérifiant une condition
42

Classe Collections
43
Méthode Définition
static <T extends Object &
Comparable<? super T>>T
min(Collection<? extends T> coll)
Cette méthode renvoie l'élément minimum de la
collection donnée, en fonction de l'ordre naturel de
ses éléments.
static <T extends Object &
Comparable<? super T> >T
max(Collection<? extends T> coll)
Cette méthode renvoie l'élément maximum de la
collection donnée, en fonction de l'ordre naturel de
ses éléments.
shuffle(List<?> list) Cette méthode permute de façon aléatoire les
éléments de la liste.
swap(List<?> list, int i, int j) Cette méthode échange les éléments de la liste aux
positions spécifiées.
fill(List<? super T> list, T obj) Cette méthode remplace tous les éléments de la liste
par l'élément passé en deuxième paramètre.
Voici quelques méthodes de cette classe:

Classe Collections
44
Méthode Définition
copy(List<? super T> dest, List<?
extends T> src)
Cette méthode copie la liste source dans la liste de
destination.
reverse(List<?> list) Cette méthode inverse l'ordre des éléments de la liste.
binarySearch(List<? extends
Comparable<? super T>> list, T
key)
Cette méthode recherche un élément dans une liste en
utilisant l'algorithme de recherche binaire. Ce mode de
recherche se base sur l’ordre naturel des objets.
replaceAll(List<T> list, T oldVal, T
newVal)
Cette méthode remplace toutes les occurrences d'une
certaine valeur par une autre.
indexOfSubList(List<?> source,
List<?> target)
Cette méthode retourne la position de départ (première
occurrence) de la première occurrence de la sous-liste
passée en paramètre. Cette méthode renverra -1 si
aucun élément n'a été trouvé.
… …

Classe Collections
45
Pour plus de details sur cette classe voir ce lien:
https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Collections.html

Interface List<E>
Une collection ordonnée (connue aussi sous le nom séquence).
L'interface List<E> modélise une liste indexée par des entiers.
Lorsque l'on ajoute un objet à une liste, il prend un numéro d'ordre,
géré par la liste. Lorsque l'on en retire un, il est de la responsabilité
de l'implémentation de la liste de conserver une numérotation
cohérente.
L’utilisateur de cette interface a le contrôle sur les places où les
éléments sont insérés.
Contrairement à un ensemble (Set), une liste peut contenir des
éléments dupliqués.
46

Interface List<E>
public interface List extends Collection {
// Positional Access
Object get(int index);
Object set(int index, Object element);
void add(int index, Object element);
boolean addAll(int index, Collection c);
Object remove(int index);
48

Interface List<E>
// recherche
int indexOf(Object o); //première occurrence
int lastIndexOf(Object o);
// Itération
ListIterator listIterator();
ListIterator listIterator(int index);
//sous liste
List subList(int from, int to);
}
49

Implémentations de l’interface List
ArrayList
maintenue dans un tableau redimensionnable
offre des fonctionnalités d’accès RAPIDE comparables à celle d’un tableau
d’objets
l'accès à un élément par son indice RAPIDE
insertion LENTE (surtout si elle a lieu au début de la liste) mais rapide en fin de
liste
LinkedList
formée de cellules liées par des références
insertion d'éléments RAPIDE
l'accès à un élément par son indice LENT
Permet de manipuler des listes dites « doublement chaînées »
Vector
similaire à ArrayList
Ces conteneurs sont des tableaux dynamiques
Ils sont bien adaptés pour manipuler des données situées à un indice
quelconque sauf au début ou à la fin de la liste auquel cas il faut leur
préférer la liste chainée LinkedList.
Toutes ces classes dérivent de l’interface List.
50

La classe ArrayList<E>
La gestion des ArrayList<E> est similaire à la gestion des
tableaux puisque le programme crée une liste par ajout de données
au fur et à mesure des besoins de l’utilisateur.
Offre des fonctionnalités d’accès rapide comparables à celle d’un
tableau d’objets.
Les données sont enregistrées dans l’ordre d’arrivée (indice).
Les données enregistrées dans une ArrayList<E> sont en réalité
rangées dans un tableau interne créé par l’interpréteur. La taille du
tableau interne est gérée automatiquement par Java.
Lorsque la liste des éléments à ajouter dépasse la taille du tableau
interne, un nouveau tableau est créé et les anciennes valeurs y sont
copiés.
51

Manipulation d’une ArrayList<E>
Déclaration :
ArrayList<E> liste = new ArrayList<E>();
Méthodes :
add(objet): ajoute un élément objet en fin de liste.
add(indice, objet): insère un élément objet à l’indice donné.
get(indice): retourne l’élément stocké à l’indice donné.
set(indice, objet): remplace l’élément situé en position indice par
l’objet.
size(): retourne le nombre d’élément dans la liste.
remove(indice): supprime l’objet dont l’indice est donné en
paramètre.
52

removeRange(i,j): supprime tous les éléments compris entre les
indices (i valeur comprise) et (j valeur comprise).
clear(): supprime tous les éléments de la liste.
indexof(objet): retourne l’indice dans la liste du premier objet
donné ou -1 si objet n’existe pas.
lastIndexof: retourne l’indice dans la liste dernier objet donné ou
-1 si objet n’existe pas.
contains (objet): retourne true ou false si l’objet existe ou non
dans la liste.
Iterator iterator(): utile pour parcourir les éléments de la liste.
53

Remarque importante:
Une liste a la capacité de mémoriser n’importe quel type d’objet, il
est donc nécessaire d’indiquer au compilateur à quel type
correspond l’objet extrait.
Object get(indice) : retourne un objet de type Object.
Utilisation de Cast (transtypage).
Les types génériques (la remède: ArrayList<E>).
54

Exemple : liste des Points
import java.util.*;
public class ListePoint{
private ArrayList liste;
public ListePoint(){ liste = new ArrayList(); }
public void ajouteUnPoint(){ liste.add(new Point()) ;}
public void afficheUnPoint(){
int nbPoint = liste.size();
if (nbPoint > 0){
Point tmp;
for(var i=0; i<nbPoint; i++){
tmp=(Point) liste.get(i);
tmp.affiche();}
}
else System.out.println(" Il n’y a pas un point dans cette liste");}}
55

Les méthodes de la classe ArrayList permettent aussi la recherche
d’un élément dans la liste grâce à la méthode indexof(objet), qui
retrouve l’indice de l’objet donné.
Dans le cas où la liste mémorise des objets complexes (tels que les
données caractéristique d’un Point ) la recherche n’est pas simple.
En fait, la méthode indexof(objet) ne retrouve l’objet donné qu’à
la seule condition qu’il soit totalement identique à celui stocké
dans la liste.
56

La classe LinkedList<E>
Cette classe implémente l’interface List en chaînant les éléments
(liste doublement chaînée).
Permet de manipuler des listes dites « doublement chaînées »
Chaque élément est lié aux éléments adjacents par une référence à
ces derniers.
Chaque élément contient une référence à l'élément précédent et à
l'élément suivant, exceptés le premier, dont l'élément précédent
vaut null, et le dernier, dont l'élément suivant vaut également null.
Elle hérite de la classe AbstractSequentialList et implémente toutes
les méthodes, même celles optionnelles, de l'interface List.
Elle possède plusieurs caractéristiques :
elle n'a pas besoin d'être redimensionnée quelque soit le nombre
d'éléments qu'elle contient.
elle permet l'ajout d'un élément null.
57

Comparaison entre tableau et LinkedList
58

Les méthodes ajoutées sont :
void addFirst(Object o): ajoute un élément en début de liste.
void addLast(Object o): ajoute un élément en fin de liste.
Object getFirst(): retourne l'élément en début de liste.
Object getLast(): retourne l'élément en fin de liste.
Object removeFirst(): supprime et retourne l'élément en début de
liste.
Object removeLast(): supprime et retourne l'élément en fin de liste.
59

Exemple 1/2:
LinkedList<String> listeChainee = new LinkedList<String>();
listeChainee.add("element 1");
Iterator iterator = listeChainee.iterator();
while (iterator.hasNext()) {
System.out.println("objet = "+iterator.next());
}
60

Exemple 2/2 :
61

Remarque (1/2):
Une liste chaînée gère une collection de façon ordonnée : l'ajout d'un
élément peut se faire au début ou à la fin de la collection. L'utilisation
d'une LinkedList est plus avantageuse par rapport à une ArrayList
lorsque des éléments doivent être ajoutés ou supprimés de la collection
en dehors de son début ou de sa fin. Dans ce cas, le temps d'exécution
des opérations se fait toujours de manière constant puisqu'elles
consistent simplement en la manipulation de pointeurs.
De par les caractéristiques d'une liste chaînée, il n'existe pas de moyen
d'obtenir un élément de la liste directement. Pourtant, la méthode
contains() permet de savoir si un élément est contenu dans la liste et la
méthode get() permet d'obtenir l'élément à la position fournie en
paramètre. Il ne faut toutefois pas oublier que ces méthodes parcourent
la liste jusqu'à obtention du résultat, ce qui peut être particulièrement
gourmand en terme de temps de réponse surtout si la méthode get() est
appelée dans une boucle. Pour cette raison, il ne faut surtout pas utiliser
la méthode get() pour parcourir la liste.
62

Remarque (2/2):
Une collection de type ArrayList permet un accès direct à un
élément dans un temps constant.
L'accès direct à un élément d'une collection de type LinkedList est
beaucoup moins performant car elle doit parcourir tous les
éléments successivement depuis le premier élément jusqu'à
l'élément désiré.
63

La classe Vector<E>
Un vecteur est un tableau dynamique dont les éléments sont des
références d'objets.
C’est un tableau d'objets dont la taille peut varier au fil du temps
public Vector(): construit un vecteur vide
public final int size() : nombre d'élément du vecteur
public final void addElement(Object obj): ajoute l'objet référencé par
obj au vecteur
public final Object elementAt(int index): référence de l'objet n° index
du vecteur - les indices commencent à 0
public final Enumeration elements(): l'ensemble des éléments du
vecteur sous forme d'énumération
64

La classe Vector<E>
public final Object firstElement(): référence du premier élément
du vecteur.
public final Object lastElement(): référence du dernier élément
du vecteur.
public final boolean isEmpty(): rend vrai si le vecteur est vide.
public final void removeElementAt(int index): enlève l'élément
d'indice index.
public final void removeAllElements(): vide le vecteur de tous
ses élément.
65

La classe Stack<E>
Une pile (Stack) contient une liste d'objets. Il est possible d'ajouter
un objet au sommet de la pile (empiler, ou push en anglais), et de
retirer l'objet situé au sommet de la pile (dépiler, ou pop en
anglais).
La classe Stack est une implémentation de pile qui dérive de la
classe Vector et ajoute les méthodes suivantes pour gérer les objets
comme une pile :
boolean empty(): retourne vrai si la pile est vide.
Object peek(): retourne l'objet au sommet de la pile sans l'enlever.
Object pop(): retourne et enlève l'objet au sommet de la pile.
Object push(Object o): ajoute l'objet au sommet de la pile.
int search(Object o): retourne l'index de l'objet depuis le sommet de
la pile (1 = sommet de la pile, -1 = non trouvé).
66

Interface Set<E>
L'interface Set<E> modélise un ensemble d'objets dans lequel on
ne peut pas trouver de doublons. Par exemple, elle n'accepte
qu'une seule fois null, car deux valeurs null sont considérées
comme un doublon. Cette notion impose que l'égalité entre objets
soit définie, ce qui est le cas, puisque tout objet Java dispose d'une
méthode equals().
Certaines implémentations empêchent l'ajout d'objets nuls dans
un Set.
À la différence des interfaces List et Collection, l'ajout d'un
élément dans un Set peut donc échouer, si cet élément s'y trouve
déjà. C'est la raison pour laquelle la méthode add(T t) retourne un
booléen. Ce booléen est toujours à true dans une collection ou une
liste, dans le cas des Set il arrive qu'il soit à false.
68

Interface Set<E>
public interface Set {
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element);
remove(Object element);
Iterator iterator();
boolean containsAll(Collection c);
void clear();
Object[] toArray();
T[] toArray(T a[]);
}
69

Interface Set<E>
Opérations ensemblistes
boolean addAll(Collection c);
boolean removeAll(Collection c);
boolean retainAll(Collection c);
Si e1 et e2 sont deux ensembles, alors:
e1.addAll(e2): représente la réunion de e1 et de e2 qui se trouve
après l’exécution dans e1.
e1.removeAll(e2): c’est le complémentaire de e2 dans e1 (e1-e2)
qui se trouve après l’exécution dans e1.
e1.retainAll(e2): c’est l’intersection de e1 et de e2 qui se trouve
après l’exécution dans e1.
70

Classes HashSet, TreeSet, LinkedHashSet
HashSet<E>, TreeSet<E> et LinkedHashSet<E> implémentent
l’interface Set<E>.
La classe HashSet<E> implémente l’interface Set<E> en utilisant
une table de hachage. C'est de loin l'implémentation la plus
performante;
TreeSet<E> utilise un arbre de recherche. Elle stocke ses éléments
triées selon leurs valeurs. Pour pouvoir utiliser un TreeSet, il faut
que les éléments soit comparables. Cette fonction est plus lente
que HashSet<E>.
LinkedHashSet<E> diffère de HashSet<E> car il maintient une
liste doublement liée à travers toutes ses entrées, permettant de
retrouver l'ordre d'insertion (mais pas pour les réinsertions).
71

Classe HashSet
Classe HashSet<E>
C'est sans nul doute la plus utilisée des implémentations de
l'interface Set<E>.
Ajout d'élément rapide et test d'appartenance très rapide.
Cette classe fonctionne avec une table de hachage, dont les clés sont
les codes de hachage des objets ajoutés, et les valeurs sont les objets
eux-mêmes.
Il est donc crucial que les méthodes equals() et hashCode() des objets
ajoutés à un HashSet respectent leur contrat.
Cette implémentation offre des performances constantes pour les
opérations add(T t), remove(T t), contains(T t) et size().
On peut parcourir ce type de collection avec un objet Iterator ou extraire
de cet objet un tableau d'Object.
72

Classe HashSet
Exemple 1/2:
import java.util.HashSet; import java.util.Iterator;
public class TestHashSet {
HashSet hs = new HashSet();
hs.add(“Marrakech");
hs.add(2020);
hs.add(‘E');
Iterator it = hs.iterator();
while(it.hasNext())
System.out.println(it.next());
System.out.println("n Parcours avec un tableau d'objets");
System.out.println("-----------------------------------");
Object[] obj = hs.toArray();
for(Object o : obj)
}}
73

Classe HashSet
Exemple 2/2:
Output:
2020
E
Marrakech
74

Classe HashSet
Classe HashSet<E>
Voici une liste des méthodes que l'on trouve dans cet objet :
add(): ajoute un élément;
contains(Object value): retourne « vrai » si l'objet contient la valeur value;
isEmpty(): retourne « vrai » si l'objet est vide;
iterator(): renvoie un objet de type Iterator;
remove(Object o): retire l'objet o de la collection;
toArray(): retourne un tableau d'Object.
75

Classe LinkedHashSet
Classe LinkedHashSet<E>
La classe LinkedHashSet<E> est une extension de HashSet<E>.
Elle offre donc les mêmes fonctionnalités et la même sémantique.
Elle entretient de plus une double liste chaînée dont les éléments
sont les entrées de la table de hachage qui stocke les objets. Cela
permet de conserver l'ordre dans lequel on parcourt les objets lors
d'une itération.
Le fait d'ajouter à un LinkedHashSet un objet qui s'y trouve déjà
ne change pas la place de cet objet dans l'ensemble.
76

Classe TreeSet
Classe TreeSet<E>
Les éléments sont placés dans (un arbre de recherche binaire
équilibré).
Les éléments sont triés.
Les opérations add(), remove(), contains() et size() sont
relativement lentes.
77

Classe TreeSet
Exemple 1/2 :
Set<String> tree = new TreeSet();
tree.add("Ahmed");
tree.add("Omar");
tree.add("Mohamed");
tree.add("Lina");
tree.add("Zakaria");
tree.add("Hiba");
Iterator<String> it = tree.iterator();
while(it.hasNext())
System.out.println(it.next());
78

Classe TreeSet
Exemple 2/2 :
Output:
Ahmed
Hiba
Lina
Mohamed
Omar
Zakaria
79

L'interface SortedSet<E> est une extension de l'interface Set<E>.
Cette interface impose de plus que tous les objets enregistrés dans cet
ensemble sont automatiquement triés dans un ordre.
Les ensembles triés peuvent être triés par défaut à leur création selon
un tri dit naturel ou qu'un motif de tri a été appliqué.
La méthode comparator() de cette interface permet de retourner le
motif de tri utilisé ou retourne null si le tri est effectué de façon naturel
en fonction du type des données.
80

L'interface SortedSet<E> propose les méthodes supplémentaires
suivantes:
comparator() : retourne l'objet instance de Comparator qui permet la comparaison,
s'il existe ou null s'il utilise l'ordre naturel des éléments.
first() et last() : retournent le plus petit objet de l'ensemble, et le plus grand,
respectivement.
SortedSet headSet(T t) : retourne une instance de SortedSet<E> contenant tous les
éléments strictement plus petit que l'élément passé en paramètre. Ce sous-ensemble est
une vue sur l'ensemble sur lequel il est construit. Il reflète donc les changements de
cet ensemble, et réciproquement.
81

SortedSet tailSet(T t) : retourne une instance de SortedSet<E> contenant
tous les éléments plus grands ou égaux que l'élément passé en paramètre.
Ce sous-ensemble est une vue sur l'ensemble sur lequel il est construit. Il
reflète donc les changements de cet ensemble, et réciproquement.
SortedSet subSet(T inf, T sup) : retourne une instance
de SortedSet<E> contenant tous les éléments plus grands ou égaux que inf,
et strictement plus petits que sup. Là encore, ce sous-ensemble est une vue
sur l'ensemble sur lequel il est construit, qui reflète donc les changements
de cet ensemble, et réciproquement.
82

L'ordre des éléments peut être défini de deux manières :
l'ordre naturel des éléments qui doivent alors implémenter
l'interface Comparable;
une instance de type Comparator qui sera invoquée pour définir
l'ordre de tri.
83

84
Voici deux exemples comment créer un SortedSet :
1) SortedSet set1 = new TreeSet();
2) Comparator comparator = new MyComparator();
SortedSet set2 = new TreeSet(comparator);

Exemple:
import java.util.*;
public class SortedSetTest {
// Créer l'ensemble trié (SortedSet)
SortedSet set = new TreeSet();
// Ajouter des éléments à l'ensemble
set.add("b"); set.add("c"); set.add("a");
// Itérer sur les éléments de l'ensemble
Iterator it = set.iterator();
while (it.hasNext()) {
// Obtenir l'élément
Object element = it.next();
System.out.println(element.toString()); } } }
85

Output:
a
b
c
86

L'interface NavigableSet est une extension de SortedSet,
introduite en Java 6.
La classe d'implémentation fournie en standard est la même que
pour SortedSet : il s'agit de TreeSet.
Elle ne modifie pas la sémantique définie pour SortedSet, mais
ajoute des méthodes et des fonctionnalités.
L'interface NavigableSet définit des fonctionnalités qui
permettent le parcours de la collection dans l'ordre ascendant ou
descendant et d'obtenir des éléments proches d'un autre élément.
87

Cette interface ajoute les méthodes suivantes à SortedSet:
iterator() et descendingIterator() : retournent deux itérateurs, qui
permettent de balayer les objets de cet ensemble dans l'ordre
croissant et décroissant, respectivement.
ceiling(T t) et floor(T t) : retournent le plus petit élément égal ou
plus grand que l'élément passé en paramètre, et le plus grand
élément égal ou plus petit que celui passé en paramètre,
respectivement.
higher(T t) et lower(T t) : retournent le plus petit élément
strictement plus grand que l'élément passé en paramètre, et le plus
grand élément strictement plus petit que celui passé en paramètre,
respectivement.
88

headSet(T sup, boolean inclusive) et tailSet(T inf, boolean inclusive) :
retournent un NavigableSet contenant les éléments plus petits
(respectivement plus grands) que l'élément passé en paramètre, inclus
ou non, suivant la valeur du booléen inclusive. Encore une fois, ce
sous-ensemble est une vue de l'ensemble maître.
subSet(T inf, boolean infInclusive ,T sup, boolean supInclusive) :
retourne un NavigableSet contenant les éléments plus grands
que inf et plus petits que sup. L'inclusion ou non des bornes est
précisée par les deux booléens passés en paramètre.
pollFirst() et pollLast() retirent de l'ensemble sa plus petite valeur, ou
sa plus grande respectivement, et la retournent.
89

Choix d'une implémentation de type Set
90
Classe add() contains() next() thread-safe
HashSet O(1) O(1) O(h/n) Non
LinkedHashSet O(1) O(1) O(1) Non
TreeSet O(log n) O(log n) O(log n) Oui
n: la taille de la collection
h: la capacité de la collection

Collections de type Map<K,V>
Les collections de type Map<K,V> sont définies et implémentées
comme des dictionnaires sous la forme d'associations de paires de
type clés-valeurs.
Organisation de données, par association d’une clé à un ensemble
de données, est appelée un dictionnaire.
La clé doit être unique. En revanche, la même valeur peut être
associée à plusieurs clés différentes.
La recherche dans un objet dans la liste s’effectue, non plus sur
l’ensemble des données qui le composent mais sur une clé unique
qui lui associée.
Une clé repère une et une seule valeur.
91

Collections de type Map<K,V>
92

Interface Map<K,V>
93
Méthode Rôle
void clear() Supprimer tous les éléments de la collection
boolean containsKey(Object) Indiquer si la clé est contenue dans la collection
boolean containsValue(Object) Indiquer si la valeur est contenue dans la collection
Set entrySet() Renvoyer un ensemble contenant les paires clé-valeur de la collection
Object get(Object key) Renvoyer la valeur associée à la clé fournie en paramètre
boolean isEmpty() Indiquer si la collection est vide
Set keySet() Renvoyer un ensemble contenant les clés de la collection
Object put(K key, V value) Insérer la clé et sa valeur associée fournies en paramètres
void putAll(Map) Insérer toutes les clés/valeurs de l'objet fourni en paramètre
Collection values() Renvoyer une collection qui contient toutes les valeurs de la
collection
Object remove(Object key) Supprimer l'élément dont la clé est fournie en paramètre
int size() Renvoyer le nombre d'éléments de la collection

Interface Map<K,V>
94
La méthode keySet() 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).
Elle définit une interface interne Map.Entry<K,V> qui définit les
fonctionnalités pour un objet qui encapsule une paire clé/valeur.
Il est recommandé d'utiliser des objets immuables comme clés.

Interface Map<K,V>
95
Une collection de type Map ne propose pas directement d'Iterator
sur ses éléments.
La collection peut être parcourue de trois manières :
parcours de l'ensemble des clés
parcours des valeurs
parcours d'un ensemble de paires clé/valeur
L'API Collections propose plusieurs implémentations de l'interface
Map notamment HashMap, TreeMap, LinkedHashMap, …

Interface Map<K,V>
96
Exemple 1/2:
import java.util.Collection; import java.util.HashMap; import java.util.Iterator;
import java.util.Map; import java.util.Map.Entry; import java.util.Set;
public class TestMap{
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "Java"); map.put(2, "Scala");
map.put(3, "Rkuby"); map.put(4, "Python");
//Nous récupérons un Set contenant des entiers
Set<Integer> setInt = map.keySet();
//Utilisation d'un itérateur générique
Iterator<Integer> it = setInt.iterator();
System.out.println("Parcours d'une Map avec keySet : ");
while(it.hasNext()){
int key = it.next();
System.out.println("Valeur pour la clé " + key + " = " + map.get(key));
}

Interface Map<K,V>
97
Exemple 2/2:
Set<Map.Entry<Integer, String>> setEntry = map.entrySet();
//Utilisation d'un iterateur générique
Iterator<Map.Entry<Integer, String>> itEntry = setEntry.iterator();
System.out.println("Parcours d'une Map avec setEntry : ");
while(itEntry.hasNext()){
Map.Entry<Integer, String> entry = itEntry.next();
System.out.println("Valeur pour la clé " + entry.getKey() + " = " + entry.getValue());}
Collection<String> col = map.values();
Iterator<String> itString = col.iterator();
System.out.println("Parcours de la liste des valeurs d'une Map avec values : ");
while(itString.hasNext()){
String value = itString.next();
System.out.println("Valeur : " + value);}
System.out.println("-----------------------------------");}
}

Interface Map<K,V>
98
Output:
Parcours d'une Map avec keySet :
Valeur pour la clé 1 = Java
Valeur pour la clé 2 = Scala
Valeur pour la clé 3 = Ruby
Valeur pour la clé 4 = Python
-----------------------------------
Parcours d'une Map avec setEntry :
Valeur pour la clé 1 = Java
Valeur pour la clé 2 = Scala
Valeur pour la clé 3 = Ruby
Valeur pour la clé 4 = Python
-----------------------------------
Parcours de la liste des valeurs d'une Map avec values :
Valeur : Java
Valeur : Scala
Valeur : Ruby
Valeur : Python
-----------------------------------

Table de hachage
99
Une table de hachage est une structure de données qui associe des
clés à des valeurs.
Une telle structure doit au moins exposer deux fonctionnalités :
une méthode de type put(key, value), qui permet d'associer un
objet à une clé.
une méthode de type get(key), qui retourne la valeur qui a été
associée à cette clé, ou null s'il n'y en a pas.
une méthode de type remove(key), qui supprime la clé de cette
table, et la valeur qui lui est associée.

Table de hachage
100
En Java, une table de hachage entretient trois ensembles.
Le premier est l'ensemble de ses clés. Il ne peut pas y avoir deux fois
la même clé dans une table de hachage, cet ensemble ne peut donc pas
posséder de doublon, il s'agit d'un Set.
Le deuxième est l'ensemble de ses valeurs. À la différence des clés,
une même valeur peut être associée à plusieurs clés différentes. Cet
ensemble est donc une Collection.
Le troisième est l'ensemble de ses entrées. Une entrée est un couple
formé par une clé et la valeur qui lui a été associée.

Interface Map.Entry
101
Cette interface permet de modéliser les couples (clé, valeur)
d'une table de hachage.
Elle expose deux méthodes : getKey() et getValue(), qui
retournent bien sûr la clé et la valeur de ce couple.
La seule façon d'obtenir un objet de type Map.Entry est de faire
un appel à la méthode Map.entrySet(), et d'itérer sur le Set obtenu
en retour.
Cet objet est une vue sur la table. Il possède également une
méthode setValue(V value), qui permet de modifier la valeur
associée à une clé durant une itération.

Classe HashMap<K,V>
Le type HashMap<K,V> permet de réaliser simplement
l’association clé-valeur en utilisant une table de hachage pour
stocker ses éléments.
Syntaxe : HashMap<K,V> map = new HashMap<K,V>();
Les méthodes :
put(clé,objet): place dans le dictionnaire l’association clé-objet.
get(clé): retourne l’objet associé à la clé donnée.
remove(clé): supprime dans le dictionnaire l’association clé-objet à partir
de la clé donnée.
size(): taille du dictionnaire.
Iterator iterator().
…
102

Classe HashMap<K,V>
La classe HashMap<K,V> présente plusieurs caractéristiques :
Elle permet l'utilisation de la valeur null comme clé et comme valeur.
Elle n'est pas thread-safe.
Elle ne garantit aucun ordre lors du parcours des éléments de la collection.
103

Classe HashMap<K,V>
Exemple 1/2 :
package projetTest; import java.util.HashMap; import java.util.Map;
public class TestCollectionsHashMap{
public static void main(String args[]){
Map<String, Integer> items = new HashMap<>();
items.put("A", 10);
items.put("B", 20);
items.put("C", 30);
items.put("D", 40);
items.put("E", 50);
items.put("F", 60);
for (Map.Entry<String, Integer> entry : items.entrySet()) {
System.out.println("Item : " + entry.getKey() + " Count : " + entry.getValue());}
} }
104

Classe HashMap<K,V>
Exemple 2/2:
Output:
105

Classe TreeMap<K,V>
106
TreeMap<K,V> stocke les éléments triés, de façon naturelle par
défaut, mais utilisable avec un comparateur.
Un dictionnaire TreeMap<K,V> trie les clés.

Classe TreeMap<K,V>
107
Exemple: Annuaire téléphonique utilisant un TreeMap<K,V>:
Map<String, String> m = new TreeMap<String, String>();
m.put(“Marrakchi”, “05 46 66 33 50”);
m.put(“Souiri”, “06 44 55 33 501”);
m.put(“Rbati”, “07 44 55 33 501”);
System.out.println(m.keySet());
System.out.println(m.values());
Output:
[Marrakchi, Rbati , Souiri]
[05 46 66 33 50, 07 44 55 33 501, 06 44 55 33 501]

Manipulation d’un TreeMap<K,V>
108
Exemple: Annuaire inversé
Map<String, String> m2 = new TreeMap<String, String>();
Set v=m2.keySet();
Iterator<String> it = v.iterator();
for(int i = 0; i<m2.size(); i++){
String s= it.next();
m2.put(m2.get(s),s);
System.out.println(m2.get(“05 46 66 33 50”));
Output:
Marrakchi

Classe LinkedHashMap<K,V>
109
LinkedHashMap<K,V> combine table de hachage et liens
chaînés pour stocker ses éléments, ce qui facilite leur insertion et
leur suppression.

110
Exemple 1/2:
Map<Integer, String> lhm = new LinkedHashMap<>();
lhm.put(10, "1");
lhm.put(20, "2");
lhm.put(30, "3");
lhm.put(40, "4");
lhm.put(50, "5");
System.out.println("Parcours de l'objet LinkedHashMap : ");
Set<Entry<Integer, String>> setLhm = lhm.entrySet();
Iterator<Entry<Integer, String>> it2 = setLhm.iterator();
while(it2.hasNext()){
Entry<Integer, String> e = it2.next();
System.out.println(e.getKey() + " : " + e.getValue());
}

111
Exemple 2/2 :
Output:
Parcours de l'objet LinkedHashMap :
10 : 1
20 : 2
30 : 3
40 : 4
50 : 5

Interface SortedMap<K,V>
112
Cette interface, SortedMap<K,V>, permet d'avoir une collection
dont les éléments sont triés selon leur ordre naturel ou via un
comparateur et ce tri sera directement visible lorsque vous
parcourrez votre collection.
De la même façon que pour SortedSet<E>, cet ordre peut être
défini de deux façons, soit par le fait que les clés de cette table
sont des objets Comparable, soit en donnant un
objet Comparator à la construction de la table.
Rappelons que les classes enveloppe des types primitifs, et la
classe String sont toutes des classes Comparable.

113
Voici un tableau qui liste quelques méthodes de cette interface :
Méthode Rôle
comparator() Retourne le comparateur utilisé pour ranger les clés de la
collection, ou null si celle-ci utilise l'ordre naturel des clés.
firstKey() Retourne la première clé de la collection.
lastKey() Retourne la plus grande de la collection.
SortedMap headMap(K toKey) Retourne une partie de la collection allant du début jusqu'au
paramètre, exclu.
SortedMap tailMap(K fromKey) Retourne une collection où les clés sont supérieures ou
égales au paramètre.
SortedMap subMap(K fromKey, K
toKey)
Retourne une sous-collection ou les clés sont comprises
entre le premier paramètre, inclus, et le deuxième paramètre,
exclu.
Set<Map.Entry<K,V>> entrySet() Retourner un ensemble des paires clé/valeur de la collection.

114
Voici deux exemples comment créer un SortedMap :
1) SortedMap map1 = new TreeMap();
2) Comparator comparator = new MyComparator();
SortedMap map2 = new TreeMap(comparator);

Interface NavigableMap<K,V>
115
L'interface NavigableMap, ajoutée dans Java 6, hérite de l'interface
SortedMap.
Elle définit des fonctionnalités qui permettent le parcours de la
collection dans l'ordre ascendant ou descendant grâce à plusieurs
méthodes.

116
L'interface NavigableMap définit plusieurs méthodes qui peuvent
être regroupées selon leur rôle :
obtenir le premier ou le dernier élément : firstEntry(),
lastEntry(), pollFirstEntry(), pollLastEntry()
obtenir un sous-ensemble de la collection : subMap(),
headMap(), tailMap()
obtenir l'élément dont la clé est la plus approchante :
ceilingEntry(), ceilingKey(), floorEntry(), floorKey(),
higherEntry(), higherKey(), lowerEntry(), lowerKey()
parcours de la collection en sens inverse : descendingMap(),
descendingKeySet(), navigableKeySet()

117
Voici quelques méthodes de l'interface NavigableMap:
ceilingKey(K key) et floorKey(K key) : retournent respectivement
la plus petite clé supérieure ou égale, et la plus grande inférieure ou
égale à la clé passée en paramètre.
ceilingEntry(K key) et floorEntry(K key) : retournent
respectivement la plus petite clé supérieure ou égale, et la plus
grande inférieure ou égale à la clé passée en paramètre.
higherKey(K key) et lowerKey(K key) : retournent respectivement
la plus petite clé strictement supérieure, et la plus grande
strictement inférieure à la clé passée en paramètre.
higherEntry(K key) et lowerEntry(K key) : retournent
respectivement la plus petite clé strictement supérieure, et la plus
grande strictement inférieure à la clé passée en paramètre.
firstEntry() et lastEntry() : retournent respectivement la plus petite
entrée de la collection, et la plus grande.

118
headMap(K sup, boolean inclusive) et tailMap(K inf, boolean
inclusive) : retournent des collections (vues), dont les clés sont plus
petites et plus grandes respectivement que la borne passée en paramètre.
Le fait que l'inégalité soit stricte ou non est réglée par la valeur du
boolean inclusive.
subMap(K fromKey, K, toKey) et subMap(K fromKey, boolean
fromInclusive, K toKey, boolean toInclusive) : retournent une collection
(vue), contenant les entrées dont les clés sont plus grandes
que fromKey et plus petites que toKey. Le fait que les bornes soient ou
non incluses dans la vue retournée est réglé par les deux
booléens fromInclusive et toInclusive.
navigableKeySet() et descendingKeySet() retournent deux collections
(vues), triés dans l'ordre de cette table et dans son ordre inverse
respectivement. Les ensembles retournés sont de type NavigableSet et
supportent les opérations de suppression.

119
pollFirstEntry() et pollLastEntry() : retirent de la table, et retournent
l'entrée dont la clé est la plus petite, respectivement la plus grande, de
cette table.
navigableKeySet() et descendingKeySet() : retournent une vue sur
l'ensemble des clés de cette table, dans l'ordre croissant et dans l'ordre
décroissant respectivement. Cette vue supporte les opérations
d'effacement, mais pas les opérations d'ajout.
descendingMap() : retourne une vue qui expose cette même table dans
l'ordre inverse. Cela signifie que si l'on itère sur les éléments (clés ou
entrées) de cette vue, cette itération se fera dans l'ordre décroissant des
clés de la table maître.

Interface Queue<E>
120
Une file d'attente est une collection normale, avec quelques
différences sémantiques. L'utilisation classique d'une file
d'attente, est de servir de tampon entre une source d'objets et un
consommateur de ces mêmes objets.
L'interface Queue<E> représente une collection gérée comme
une file d'attente.
Elle permet donc de prioriser les tâches de traitement des données
qu'elle contient.
Ces objets utilisent généralement (mais pas obligatoirement) un
mode de gestion de type FIFO, ce qui signifie que le premier
élément ajouté à la collection sera le premier à en sortir.
À la différence des collections, les files d'attente ont une capacité
limitée. Il se peut que l'ajout d'un objet dans une file d'attente
échoue.

Interface Queue<E>
121
Traditionnellement, une file d'attente expose trois types de méthodes:
ajout d'un objet dans la file;
examen de l'objet suivant disponible;
consommation de l'objet suivant disponible, et retrait de la file.

Interface Queue<E>
122
L'interface Queue<E>, qui modélise une file d'attente simple,
expose six méthodes, qui sont les suivantes.
add(T t) et offer(T t) permettent d'ajouter un élément à la liste. Si la
capacité maximale de la liste est atteinte, alors add() jette une
exception de type IllegalStateException, et offer() retourne false.
remove() et poll() retirent toutes les deux de cette file d'attente. Si
aucun élément n'est disponible, alors remove() jette une exception
de type NoSuchElementException, tandis que poll() retourne null.
element() et peek() examinent toutes les deux l'élément disponible,
sans le retirer de la file d'attente. Si aucun élément n'est disponible,
alors element() jette une exception de type
NoSuchElementException, tandis que peek() retourne null.

Interface Deque<E>
124
L’interface Deque<E> est une extension de Queue<E>, ajoutée
en Java 6.
Le terme "deque" est une abréviation de "double ended queue".
La particularité principale de l’interface Deque<E> est qu'elle
permet d'insérer et de retirer des éléments dans les deux sens de la
file, avec la même sémantique que pour Queue<E>.
De ce fait, il existe des méthodes qui permettent d'ajouter et de
retirer des éléments aux deux extrémités.

Interface Deque<E>
125
L’interface Deque<E> expose trois types de méthodes, qui
permettent d'ajouter, de retirer, ou d'examiner l'élément suivant de
la file.
Chacune de ces méthodes existe en deux versions : la première agit
sur une extrémité de la file, et la seconde sur l'autre.
Chacune de ces méthodes existe encore en deux versions : la
première jette une exception en cas d'échec, la seconde
retourne false.

Interface Deque<E>
126
Cela fait un total de douze méthodes, que l'on peut regrouper dans
le tableau suivant:
Jette une exception Retourne false
Insertion addFirst(T t) / addLast(T t) offerFirst(T t) / offerLast(T t)
Retrait removeFirst(T t) / removeLast(T t) pollFirst(T t) / pollLast(T t)
Examen getFirst(T t) / getLast(T t) peekFirst(T t) / peekLast(T t)

Interface Deque<E>
127
L'interface Deque<E> expose également les deux
méthodes iterator() et descendingIterator(), qui permettent d'itérer
dans les deux sens de la file d'attente.
Enfin, elle expose deux
méthodes removeFirst(Object) et removeLast(Object), qui
permettent de retirer respectivement la première et la dernière
occurrence de l'objet passé en paramètre.

Les Enumérations
Les énumérations constituent une notion nouvelle depuis Java 5.
Ce sont des structures qui définissent une liste de valeurs
possibles.
Les énumérations ne sont pas très difficile à utiliser et nos
programmes y gagnent en rigueur et en clarté.
Il permet de créer des types de données personnalisés.
Par exemple construire le type Langage qui ne peut prendre qu'un
certain nombre de valeurs : JAVA, PHP, C, etc.
128

Les Enumérations
Une énumération est une classe contenant une liste de sous-objets.
Une énumération se construit grâce au mot clé enum.
Les enum héritent de la classe java.lan.Enum.
Chaque élément d’une énumération est un objet à part entière.
Vous pouvez compléter les comportements des objets d’une
énumération en ajoutant des méthodes.
129

Les Enumérations
130
Une énumération se déclare comme une classe en remplaçant le
mot-clé class par enum.
public enum Langage{
JAVA,
C,
CPlus,
PHP;
}

Les Enumérations
131
Exemple 1/2:
public class TestEnumeration{
public static void main(String [] args){
for(Langage lang : Langage.values()){
if (Langage.JAVA.equals(lang))
System.out.println("J’aime le langage " + lang);
else
System.out.println(lang);
}
}
}

Les Enumérations
132
Exemple 2/2 :
Output:
J’aime le langage JAVA
C
CPlus
PHP

Les Enumérations
133
//objets directement construits
JAVA ("Langage Java 13"), RUBY ("Langage Ruby"),
SCALA ("Langage Scala"), PYTHON ("Langage Python");
private String name = " ";
//constructeur
Langage(String name){
this.name=name;}
return name;}
}

Les Enumérations
134
Output:
J’aime le Langage Java 13
Langage Ruby
Langage Scala
Langage Phyton

Les Enumérations
135
Exemple complet:
//objets directement construits
JAVA ("Langage Java 13", "Eclipse"), RUBY ("Langage Ruby", "Dar AlMaarifa"),
SCALA ("Langage Scala", " Dar Alkoutoub"), PYTHON ("Langage Python", " Eyrolles");
private String name = " "; private String editor = " ";
//constructeur
Langage(String name, String editor){this.name=name; this.editor=editor;}
public void getEditor(){System.out.println(" Editeur : " +editor);}
public String toString(){return name;}
public void static main(String args[]){
Langage l1 = Langage.JAVA; Langage l2 = Langage.SCALA;
l1.getEditor(); l2.getEditor();
} }

Les Enumérations
136
Exemple complet:
Output:
Editeur : Eclipse
Editeur : Dar Alkoutoub

Les Enumérations
137
Exemples :
Enumération: Ensemble des constantes:
public enum Day{
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAY}
Autre exemple: les points cardinaux
public enum Pc{
NORTH, EST, SOUTH, WEST}
Autre exemple: les planètes du système solaire
public enum Planet{
MERCURY, EARTH, MARS, JUPITER, SATURN, URANUS,
NEPTUNE}

Les Enumérations
138
Exemple 1/3:
public class TellHowDayIs{
Day day;
public TellHowDayIs(Day d){day=d;}
public void tellItLikeItIs(){
switch(day){
case MONDAY:
System.out.println("Mondays are bad ");break;
case SATURDAY :
case SUNDAY :
System.out.println(" Weekends are best");break;
default:
System.out.println(" Midweek days are so-so");break;
}}}

Les Enumérations
139
Exemple 2/3:
public class TestEnum{
TellHowDayIs firstDay = new TellHowDayIs(Day.MONDAY);
firstDay.tellItLikeItIs();
TellHowDayIs lastDay = new TellHowDayIs(Day.SATURDAY);
lastDay.tellItLikeItIs();
}
}

Les Enumérations
140
Exemple 3/3:
Output:
Mondays are bad
Weekends are best

Les Enumérations
141
Exemple 1/3:
public enum Planet{
MERCURY (3.303e+23, 2.4397e6),
EARTH (5.976e+24, 6.37814e6),
MARS (6.421e+23, 3.3972e6),
JUPITER (1.9e+27, 7.1492e7);
private final double mass;
private final double radius;
Planet(double m, double r){mass=m; radius=r;}
private static final double G=6.673E-11;
double surfaceGravity(){return G*mass/(radius*radius);}
double surfaceWeight(double val){return val*surfaceGravity();}

Les Enumérations
142
Exemple 2/3:
public class TestEnum{
double earthWeight = 70;
Planet terre = Planet.EARTH;
double mass = earthWeight/terre.surfaceGravity();
for(Planet p:Planet.values()){
System.out.println(" Weight on
"+p.name()+"is"+p.surfaceWeight(mass));
}
}
}

Les Enumérations
143
Exemple 3/3:
Output:
Weight on MERCURY is 26.44303306406547
Weight on EARTH is 70.0
Weight on MARS is 26.51160288259902
Weight on JUPITER is 177.13902678470185

145
Références
1. Programmer en Java, Claude Delannoy, Eyrolles, 2016
2. Programmation orientée objet avec Java, Jacques Bapst, École d’Ingénieurs et
d’Architectes de Fribourg.
3. http://blog.paumard.org/cours/java/
4. http://www.tutorialspoint.com/java/
5. https://www.jmdoudoux.fr/java/dej/chap-collections.htm
6. https://openclassrooms.com/courses/java-et-les-collections
7. https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Collection.html
8. https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/List.html
9. https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Set.html
10. https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Queue.html
11. https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Map.html

Chapitre8: Collections et Enumerations En Java

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Chapitre8: Collections et Enumerations En Java

Semelhante a Chapitre8: Collections et Enumerations En Java (20)

Mais de Aziz Darouichi

Mais de Aziz Darouichi (10)

Chapitre8: Collections et Enumerations En Java