Les ensembles des collections non ordonnées d'objets

dans lesquelles un objet ne peut apparaître qu'au plus une

seule fois. Ils n’autorisent pas les doublons ni l’accès direct
à un élément de la collection. Les fonctionnalités de base
des ensembles sont définies dans l'interface java.util.Set.
Ainsi l'interface Set possède deux interfaces filles :
SortedSet(Set trié) et NavigableSet.(fournit des méthodes
pour la navigation dans l’ensemble en plus des opérations
de SortedSet).
En Java, les ensembles (ou collections) sont essentiels car ils permettent de stocker
et manipuler efficacement des groupes d'objets. Ils offrent une gestion simplifiée
des données multiples, garantissent l'unicité des éléments, et sont optimisés pour
des performances élevées. De plus, ils s'intègrent facilement avec d'autres
fonctionnalités du langage, ce qui les rend polyvalents et adaptés à de nombreuses
applications.
- HashSet : Implémente un ensemble non trié

- TreeSet : Implémente un ensemble trié en utilisant un arbre binaire

- LinkedHashSet : Implémente un ensemble dans lequel vous avez besoin de conserver

l'ordre d'insertion des éléments,

- EnumSet : Spécialisé pour les ensembles contenant des éléments d'une énumération.

- CopyOnWriteArraySet : Implémente un ensemble basé sur un tableau, où toutes les

opérations de modification (ajout, suppression) sont effectuées en copiant l'ensemble
sous-jacent.
• Les implémentations d'ensembles les plus couramment utilisées en Java sont les classes
HashSet, TreeSet, LinkedHashSet.

• Chaque fois qu’on introduit un nouvel élément dans une collection de type HashSet ou
TreeSet ou encore LinkedHashSet, il est nécessaire de s’assurer qu’il n’y figure pas déjà, il
faudra alors se préoccuper des méthodes equals() et compareTo(); equals() est utilisé
pour garantir l'unicité des éléments dans tous les types d'ensembles (HashSet, TreeSet,
LinkedHashSet), tandis que compareTo() est spécifique à TreeSet pour maintenir un ordre
spécifique des éléments.
• Un ensemble est une structure de données qui permet de stocker un groupe d'éléments de
manière non ordonnée et sans éléments dupliqués. Contrairement aux listes, les
ensembles ne garantissent pas un ordre spécifique des éléments et ne permettent pas la
duplication des éléments.

• Les ensembles sont utiles lorsque vous avez besoin de stocker des éléments uniques et
que l'ordre des éléments n'est pas important. Par exemple, lorsque vous souhaitez
maintenir une liste d'utilisateurs uniques ou une liste de mots-clés uniques.

• Les listes, en revanche, permettent de stocker des éléments dans un ordre spécifique et
autorisent la duplication des éléments. Elles sont utilisées lorsque vous avez besoin de
maintenir un ordre précis des éléments ou de permettre des duplications. Par exemple,
lorsque vous souhaitez conserver l'ordre des tâches à effectuer ou lorsque vous autorisez
plusieurs entrées de la même valeur.
• Suppression des doublons : Par exemple, si vous avez une liste d'adresses e-mail et que
vous souhaitez vous assurer qu'aucune adresse n'apparaît deux fois, vous pouvez utiliser
un ensemble pour stocker les adresses uniques

• Vérification de l'appartenance : Les ensembles sont également utiles pour vérifier si un

élément est présent dans une collection sans avoir à parcourir toute la collection

• Gestion des autorisations : Dans les systèmes de gestion des autorisations, les ensembles
peuvent être utilisés pour représenter les autorisations accordées à un utilisateur.

• Calcul d'intersection ou d'union : Les ensembles peuvent être utilisés pour calculer des
opérations ensemblistes telles que l'intersection, l'union, la différence, etc. Par exemple, si
vous avez deux ensembles de mots-clés et que vous souhaitez trouver les mots-clés
communs aux deux ensembles, vous pouvez calculer l'intersection des ensembles
• Les éléments ajoutés dans une collection de type Set doivent réimplémenter leurs
méthodes equals() et hashCode(). Ces méthodes sont utilisées lors de l'ajout d'un élément
pour déterminer s'il est déjà présent dans la collection. La valeur retournée par hashCode()
est recherchée dans la collection :

❑ Si aucun objet de la collection n'a la même valeur de hachage alors l'objet n'est pas
encore dans la collection et peut être ajouté

❑ Si un ou plusieurs objets de la collection ont la même valeur de hachage alors la méthode

equals() de l'objet à ajouter est invoquée sur chacun des objets pour déterminer si l'objet
est déjà présent ou non dans la collection

❑ Une collection de type Set peut contenir un objet null mais cela dépend des
implémentations. Certaines d'entre-elles ne permettent pas l'ajout de null.
 L'interface définit plusieurs méthodes parmi lesquelles nous pouvons citer :
Méthode Rôle
Ajouter l'élément fourni en paramètre à la collection si celle-ci ne le contient pas déjà et
boolean add(E e) renvoyer un booléen qui précise si la collection a été modifiée (l'implémentation de cette
opération est optionnelle)
boolean Ajouter tous les éléments de la collection fournie en paramètre à la collection si celle-ci ne
addAll(Collection<? les contient pas déjà et renvoyer un booléen qui précise si la collection a été modifiée
extends E> c) (l'implémentation de cette opération est optionnelle)
Retirer tous les éléments de la collection (l'implémentation de cette opération est
void clear()
optionnelle)
boolean contains(Object
Renvoyer un booléen qui précise si la collection contient l'élément fourni en paramètre
o)
boolean
Renvoyer un booléen qui précise si tous les éléments de la collection fournie en paramètre
containsAll(Collection<?>
sont contenus dans la collection
c)
Comparer l'égalité de la collection avec l'objet fourni en paramètre. L'égalité est vérifiée si
boolean equals(Object
l'objet est de type Set, que les deux collections ont le même nombre d'éléments et que
o)
chaque élément d'une collection est contenu dans l'autre
int hashCode() Retourner la valeur de hachage de la collection
 boolean isEmpty() Renvoyer un booléen qui précise si la collection est vide

Iterator<E> iterator() Renvoyer un Iterator sur les éléments de la collection

Retirer l'élément fourni en paramètre de la collection si celle-ci le contient et renvoyer un

boolean remove(Object
booléen qui précise si la collection a été modifiée (l'implémentation de cette opération est
o)
optionnelle)
boolean Retirer les éléments fournis en paramètres de la collection si celle-ci les contient et
removeAll(Collection<?> renvoyer un booléen qui précise si la collection a été modifiée. (l'implémentation de cette
c) opération est optionnelle)
boolean Retirer tous les éléments de la collection qui ne sont pas dans la collection fournie en
retainAll(Collection<?> c) paramètre (l'implémentation de cette opération est optionnelle)

Renvoyer le nombre d'éléments de la collection. Si ce nombre dépasse Integer.MAX_VALUE

int size()
alors la valeur retournée est MAX_VALUE

Object[] toArray() Renvoyer un tableau des éléments de la collection

Renvoyer un tableau des éléments de la collection dont le type est celui fourni en
<T> T[] toArray(T[] a)
paramètre
 La classe HashSet présente plusieurs caractéristiques :

• Elle ne propose aucune garantie sur l'ordre de parcours lors de l'itération sur les éléments
qu'elle contient
• Elle ne permet pas d'ajouter des doublons mais elle permet l'ajout d'un élément null

La classe HashSet possède plusieurs constructeurs :

Constructeur Rôle

Créer une nouvelle instance vide dont la HashMap interne utilisera une capacité initiale et
HashSet()
un facteur de charge par défaut

HashSet(Collection<?
Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
extends E> c)

HashSet(int Créer une nouvelle instance vide dont la HashMap interne utilisera la capacité initiale
initialCapacity) fournie en paramètre et un facteur de charge par défaut
HashSet(int
Créer une nouvelle instance vide dont la HashMap interne utilisera la capacité initiale et un
initialCapacity, float
facteur de charge par défaut
loadFactor)
• Le LinkedHashSet est une version ordonnée de HashSet qui maintient une liste à double lien
sur tous les éléments.

• Lorsque l’ordre d’itération doit être maintenu, cette classe est utilisée. Lors de l’itération
dans un HashSet , l’ordre est imprévisible, tandis qu’un LinkedHashSet nous permet de
parcourir les éléments dans l’ordre dans lequel ils ont été insérés.

• Lorsque vous parcourez LinkedHashSet à l’aide d’un itérateur, les éléments seront renvoyés
dans l’ordre dans lequel ils ont été insérés.
• Cette classe permet d'insérer des éléments dans n'importe quel ordre et de restituer. dans
un ordre précis lors de son parcours.

• L'ordre des éléments de la collection peut être défini par deux moyens :

❑ L’ordre naturel des éléments s'ils implémentent l'interface Comparable

❑ L’ordre obtenu par l'utilisation d'une instance de type Comparator fournie en paramètre
du constructeur de la collection

❑ La classe TreeSet utilise un arbre binaire pour stocker ses éléments. Chaque élément est
encapsulé dans un noeud (node).

❑ Si un noeud fait référence à un ou deux autres noeuds alors il est le noeud parent de ses
noeuds fils

❑ Si un noeud n'a pas de fils alors c'est une feuille de l'arbre.

 L'ajout d'un noeud fils suit toujours les mêmes règles :

❑ Un des deux noeuds contient toujours un élément dont la valeur est plus petite

❑ L’autre noeud contient toujours un élément dont la valeur est supérieure

❑ C’est toujours le même noeud qui doit contenir la valeur la plus petite et l'autre la valeur la
plus grande
5
3 9

1 4 6 7

2 5
 La classe TreeSet possède plusieurs constructeurs :

Constructeur Rôle

TreeSet() Créer une instance vide dont l'ordre naturel de tri de ses éléments est utilisé

TreeSet(Collection<? extends Créer une instance contenant les éléments de la collection fournie en paramètre dont l'ordre naturel de tri de
E> c) ses éléments est utilisé

TreeSet(Comparator<? super Créer une instance vide dont l'ordre utilisé est celui définit par l'instance de type Comparator fournie en
E> comparator) paramètre
Créer une instance contenant les éléments de la collection fournie en paramètre dont l'ordre est celui utilisé
TreeSet(SortedSet<E> s)
par la collection
 La classe HashSet présente plusieurs caractéristiques :

❑ Les éléments sont ordonnés dans leur ordre naturel

❑ Le parcours ascendant des éléments est plus rapide que le parcours descendant.
❑ Elle ne permet pas de contenir un objet null.
❑ Elle implémente toutes les méthodes optionnelles de l'interface Set
La classe ConcurrentSkipListSet possède plusieurs constructeurs :

Constructeur Rôle

ConcurrentSkipListSet() Créer une nouvelle instance vide dont les éléments sont triés avec leur ordre naturel

ConcurrentSkipListSet(C Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
ollection<? extends E> c) triés avec leur ordre naturel

ConcurrentSkipListSet(C
Créer une nouvelle instance vide dont les éléments sont triés en utilisant l'instance de type
omparator<? super E>
Comparator fournie en paramètre
comparator)
ConcurrentSkipListSet(So Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
rtedSet<E> s) triés selon l'ordre de cette collection
 La classe HashSet présente plusieurs caractéristiques :

❑ Les éléments sont ordonnés dans leur ordre naturel

❑ Le parcours ascendant des éléments est plus rapide que le parcours descendant.
❑ Elle ne permet pas de contenir un objet null.
❑ Elle implémente toutes les méthodes optionnelles de l'interface Set
La classe ConcurrentSkipListSet possède plusieurs constructeurs :

Constructeur Rôle

ConcurrentSkipListSet() Créer une nouvelle instance vide dont les éléments sont triés avec leur ordre naturel

ConcurrentSkipListSet(C Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
ollection<? extends E> c) triés avec leur ordre naturel

ConcurrentSkipListSet(C
Créer une nouvelle instance vide dont les éléments sont triés en utilisant l'instance de type
omparator<? super E>
Comparator fournie en paramètre
comparator)
ConcurrentSkipListSet(So Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
rtedSet<E> s) triés selon l'ordre de cette collection
 La classe ConcurrentSkipListSet présente plusieurs caractéristiques :

❑ Les éléments sont ordonnés dans leur ordre naturel s'ils implémentent l'interface
Comparable ou selon un ordre défini par l'instance de type Comparator fournie au
constructeur de l'instance de la collection.

❑ Le parcours ascendant des éléments est plus rapide que le parcours descendant.

❑ Elle ne permet pas de contenir un objet null.

❑ Les opérations de la classe ConcurrentSkipListSet sont de types CAS (Compare And

Swap) : elles ne posent aucun verrou qui pourrait introduire de la contention.

❑ Elle implémente toutes les méthodes optionnelles de l'interface Set

 La classe ConcurrentSkipListSet possède plusieurs constructeurs :

Constructeur Rôle

ConcurrentSkipListSet() Créer une nouvelle instance vide dont les éléments sont triés avec leur ordre naturel

ConcurrentSkipListSet(C Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
ollection<? extends E> c) triés avec leur ordre naturel

ConcurrentSkipListSet(C
Créer une nouvelle instance vide dont les éléments sont triés en utilisant l'instance de type
omparator<? super E>
Comparator fournie en paramètre
comparator)

ConcurrentSkipListSet(So Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
rtedSet<E> s) triés selon l'ordre de cette collection
 La classe CopyOnWriteArraySet présente plusieurs caractéristiques :

❑ Elle est thread safe

❑ Les opérations de mises à jour de la collection sont coûteuses en ressources car elles
impliquent une copie intégrale des éléments du tableau

❑ Le parcours grâce à un Iterator ne peut être influencé par une opération d'un autre
thread : l'itération se fait sur une copie dédiée des éléments du tableau

❑ Les Iterator ne proposent pas de support pour la méthode remove()

 La classe CopyOnWriteArraySet possède plusieurs constructeurs :

Constructeur Rôle

CopyOnWriteArraySet () Créer une nouvelle instance vide

CopyOnWriteArraySet
(Collection<? extends E> Créer une nouvelle instance contenant les éléments de la collection fournie en paramètre
c)
 Le JDK contient plusieurs implémentations généralistes de l'interface Set qui peuvent
selon les besoins :

❑ Maintenir un ordre des clés

❑ Gérer des accès concurrents

Ordre des clés Pas d'accès concurrent Gestion des accès concurrents

Aucun HashSet

Trié TreeSet ConcurrentSkipListMap

Fixe LinkedHashSet CopyOnWriteArraySet

Les ensembles en Java sont des collections
qui ne contiennent pas de doublons. Ils
offrent des opérations pour ajouter,
supprimer, rechercher et itérer sur les
éléments de manière efficace.
Pour ajouter des éléments à un ensemble en Java, on utilise la méthode add() de l'interface
Set. Voici un exemple :

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

ensemble.add(1);

ensemble.add(2);

ensemble.add(3);

L'unicité des éléments est garantie par la structure même de l'ensemble. Si vous essayez
d'ajouter un élément déjà présent, il ne sera pas ajouté une deuxième fois.
Pour supprimer des éléments d'un ensemble, on dispose de plusieurs méthodes, notamment
remove(Object o) et clear()

❑ remove(Object o): Cette méthode permet de supprimer un élément spécifique de

l'ensemble. Voici un exemple :

boolean contientDeux = ensemble.contains(2); // Vérifie si l'ensemble contient l'élément 2

boolean estVide = ensemble.isEmpty(); // Vérifie si l'ensemble est vide

Pour rechercher des éléments dans un ensemble, on utilise les méthodes contains(Object o)
et isEmpty().

boolean contientDeux = ensemble.contains(2); // Vérifie si l'ensemble contient l'élément 2

boolean estVide = ensemble.isEmpty(); // Vérifie si l'ensemble est vide

Pour parcourir les éléments d'un ensemble, on peut utiliser une boucle for-each ou un
itérateur.

- Utilisation d'une boucle for-each :

for (Integer element : ensemble) {

System.out.println(element);
}
- Utilisation d'un itérateur :

Iterator<Integer> it = ensemble.iterator();
while (it.hasNext()) {
Integer element = it.next();
System.out.println(element);
}
n
d
'
é
l
é
m
e
n
t
s
Les ensembles en Java peuvent être utilisés
de manière plus avancée pour effectuer
diverses opérations et analyses sur les
données. Voici quelques-unes des
utilisations avancées des ensembles
Les ensembles peuvent être convertis en d'autres types de collections et vice versa. Cela
peut être utile lorsque vous devez manipuler des données dans différents contextes ou avec
différentes structures de données.

Conversion d'un ensemble en une liste :

Set<String> ensemble = new HashSet<>();

ensemble.add("Java");

ensemble.add("Python");

ensemble.add("C++");

List<String> liste = new ArrayList<>(ensemble);

Conversion d'une liste en un ensemble :

List<String> liste = new ArrayList<>();

liste.add("Java");

liste.add("Python");

liste.add("C++");

Set<String> ensemble = new HashSet<>(liste);

Conversion d’un ensemble en tableau :

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

ensemble.add(1);

ensemble.add(2);

ensemble.add(3);

ensemble.add(4);

Integer[] tableau = ensemble.toArray(new Integer[0]);

Conversion d’un tableau en ensemble

Integer[] tableau = {1, 2, 3, 4, 5};

Set<Integer> ensemble = new HashSet<>(Arrays.asList(tableau));

Les ensembles peuvent être comparés pour trouver des éléments communs, différents ou
pour vérifier s'ils sont égaux.

Intersection (éléments communs) : Les éléments présents dans les deux ensembles.

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

ensemble1.add(1);
ensemble1.add(2);
ensemble1.add(3);

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

ensemble2.add(2);
ensemble2.add(3);
ensemble2.add(4);

ensemble1.retainAll(ensemble2) ; // Les éléments communs entre ensemble1 et //ensemble2

Différence (éléments uniques) : Les éléments présents dans le premier ensemble mais pas
dans le deuxième.

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

ensemble1.add(1);
ensemble1.add(2);
ensemble1.add(3);

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

ensemble2.add(2);
ensemble2.add(3);
ensemble2.add(4);

ensemble1.removeAll(ensemble2); // Les éléments uniques dans ensemble1 par //rapport à

ensemble2
Union (tous les éléments) : Tous les éléments des deux ensembles, sans doublons.

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

ensemble1.add(1);
ensemble1.add(2);

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

ensemble2.add(2);
ensemble2.add(3);

ensemble1.addAll(ensemble2); // Tous les éléments de ensemble1 et ensemble2, sans

//doublons
En plus des opérations de base comme l'ajout et la suppression d'éléments, les ensembles en
Java prennent en charge des opérations ensemblistes telles que l'union, l'intersection et la
différence.

Union : Combinaison de deux ensembles, excluant les doublons

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

ensemble1.add(1);
ensemble1.add(2);

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

ensemble2.add(2);
ensemble2.add(3);

Set<Integer> union = new HashSet<>(ensemble1);

union.addAll(ensemble2); // Union de ensemble1 et ensemble2
Intersection : Les éléments présents dans les deux ensembles.

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

ensemble1.add(1);
ensemble1.add(2);
ensemble1.add(3);

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

ensemble2.add(2);
ensemble2.add(3);
ensemble2.add(4);

Set<Integer> intersection = new HashSet<>(ensemble1);

intersection.retainAll(ensemble2); // Intersection de ensemble1 et ensemble2

Différence : Les éléments présents dans le premier ensemble mais pas dans le deuxième.

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

ensemble1.add(1);
ensemble1.add(2);
ensemble1.add(3);

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

ensemble2.add(2);
ensemble2.add(3);
ensemble2.add(4);

Set<Integer> difference = new HashSet<>(ensemble1);

difference.removeAll(ensemble2); // Différence de ensemble1 par rapport à ensemble2

Les ensembles en Java offrent un moyen efficace de gérer
des collections d'objets uniques sans doublons. Leur
unicité et leur capacité à maintenir l'ordre les rendent
particulièrement adaptés à de nombreux problèmes de
programmation. Il est clair que les ensembles jouent un rôle
crucial dans le développement Java et qu'ils offrent un
potentiel considérable pour simplifier et optimiser le code.
Il est donc fortement recommandé d'explorer davantage les
ensembles pour en tirer pleinement parti dans vos projets
de programmation Java.
 Présentation Réalisée par :
AMAVIGAN Ayi Mawuli Henoc
BASSOWOU Kokou Edouard
DJIBOM Mardia Dilane
EKLOU Kossi Dodji
LAWSON-BODY Latévi Josué
WILSON-BAHUN Adjé Sitou Jean-Cyrille