Classe Java HashSet : Guide Complet sur les Opérations, Méthodes et Théorie des Ensembles

Classe Java HashSet

Explorez la classe Java HashSet – sa création, méthodes principales et opérations pratiques sur les ensembles – à travers des exemples concis.

La classe HashSet, partie du framework de collections Java, implémente l'interface Set et offre un stockage basé sur table de hachage.

---

Création d'un HashSet

Importez d'abord java.util.HashSet :

import java.util.HashSet;

Puis créez un HashSet avec une capacité et un facteur de charge spécifiques :

HashSet<Integer> numbers = new HashSet<>(8, 0.75); // capacité=8, loadFactor=0.75

Paramètres :

• capacity – nombre initial de buckets (8 dans cet exemple).
• loadFactor – seuil déclenchant le redimensionnement (0.75 signifie redimensionner quand 75% plein).

L'utilisation des défauts est aussi courante :

HashSet<Integer> numbers1 = new HashSet<>(); // capacité=16, loadFactor=0.75

---

Méthodes de HashSet

Voici les méthodes les plus fréquemment utilisées :

• add(T element) – insère un seul élément.
• addAll(Collection<? extends T> c) – insertion en masse.
• remove(Object o) – supprime un élément spécifique.
• removeAll(Collection<? extends Object> c) – efface plusieurs éléments.
• contains(Object o) – vérifie la présence.
• size() – nombre d'éléments.
• clear() – supprime toutes les entrées.
• clone() – crée une copie superficielle.
• isEmpty() – teste si vide.
• containsAll(Collection<? extends Object> c) – vérification de sous-ensemble.

---

Insertion d'Éléments

Exemple utilisant add et addAll :

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> evenNumber = new HashSet<>();
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("HashSet: " + evenNumber);
        HashSet<Integer> numbers = new HashSet<>();
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("Nouveau HashSet: " + numbers);
    }
}

Sortie

HashSet: [2, 4, 6] Nouveau HashSet: [2, 4, 5, 6]

---

Accès aux Éléments

Itérez avec Iterator :

import java.util.HashSet;
import java.util.Iterator;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("HashSet avec Iterator: ");
        while(iterate.hasNext()) {
            System.out.print(iterate.next() + ", ");
        }
    }
}

Sortie

HashSet: [2, 5, 6] HashSet avec Iterator: 2, 5, 6,

---

Suppression d'Éléments

Suppression unique et vidage de l'ensemble :

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("HashSet: " + numbers);
        boolean removed = numbers.remove(5);
        System.out.println("5 est-il supprimé? " + removed);
        boolean cleared = numbers.removeAll(numbers);
        System.out.println("Tous les éléments sont-ils supprimés? " + cleared);
    }
}

Sortie

HashSet: [2, 5, 6] 5 est-il supprimé? true Tous les éléments sont-ils supprimés? true

---

Opérations sur les Ensembles

Les méthodes en masse de HashSet supportent les opérations classiques de la théorie des ensembles.

Union

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(3);
        numbers.addAll(evenNumbers);
        System.out.println("L'union est: " + numbers);
    }
}

Sortie

L'union est: [1, 2, 3, 4]

Intersection

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        HashSet<Integer> evenNumbers = new HashSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        evenNumbers.retainAll(primeNumbers);
        System.out.println("L'intersection est: " + evenNumbers);
    }
}

Sortie

L'intersection est: [2]

Différence

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        primeNumbers.add(5);
        HashSet<Integer> oddNumbers = new HashSet<>();
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Différence: " + primeNumbers);
    }
}

Sortie

Différence: [2]

Vérification de Sous-ensemble

import java.util.HashSet;
class Main {
    public static void main(String[] args) {
        HashSet<Integer> numbers = new HashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        HashSet<Integer> primeNumbers = new HashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        boolean isSubset = numbers.containsAll(primeNumbers);
        System.out.println("primeNumbers est-il un sous-ensemble de numbers? " + isSubset);
    }
}

Sortie

primeNumbers est-il un sous-ensemble de numbers? true

---

Méthodes Supplémentaires

Méthode	Description
clone()	Crée une copie superficielle de l'ensemble.
contains()	Vérifie si un élément existe.
isEmpty()	Retourne true si l'ensemble est vide.
size()	Nombre d'éléments dans l'ensemble.
clear()	Supprime tous les éléments.

Pour une liste complète, référez-vous à la documentation officielle Java.

---

Pourquoi Utiliser HashSet?

Quand l'accès aléatoire est requis, HashSet offre une performance O(1) grâce à son appui par table de hachage. Le hashCode() de chaque élément garantit l'unicité, prévenant les doublons. Cependant, HashSet n'est pas thread-safe ; une synchronisation externe est nécessaire pour l'usage concurrent.

Note : Comme HashSet n'est pas synchronisé, plusieurs threads le modifiant simultanément peuvent corrompre la structure de données.