Maîtriser Java LinkedHashSet : Fonctionnalités, Méthodes et Exemples Pratiques

Java LinkedHashSet

Dans ce tutoriel, nous apprendrons la classe Java LinkedHashSet et ses méthodes avec l'aide d'exemples.

La classe LinkedHashSet du framework de collections Java fournit les fonctionnalités à la fois de la table de hachage et de la structure de données liste chaînée.

Elle implémente l'interface Set.

Les éléments de LinkedHashSet sont stockés dans des tables de hachage similaires à HashSet.

Cependant, les linked hash sets maintiennent une liste doublement chaînée en interne pour tous leurs éléments. La liste chaînée définit l'ordre dans lequel les éléments sont insérés dans les tables de hachage.

Créer un LinkedHashSet

Pour créer un linked hash set, nous devons d'abord importer le package java.util.LinkedHashSet.

Une fois le package importé, voici comment nous pouvons créer des linked hash sets en Java.

// LinkedHashSet avec capacité 8 et facteur de charge 0.75
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Ici, nous avons créé un linked hash set nommé numbers.

Remarquez la partie new LinkedHashSet<>(8, 0.75). Ici, le premier paramètre est capacity et le second est loadFactor.

capacity - La capacité de ce hash set est 8. Signifiant, il peut stocker 8 éléments.
loadFactor - Le facteur de charge de ce hash set est 0.6. Cela signifie que chaque fois que notre table de hachage est remplie à 60%, les éléments sont déplacés vers une nouvelle table de hachage de taille double.

Capacité et facteur de charge par défaut

Il est possible de créer un linked hash set sans définir sa capacité et son facteur de charge. Par exemple,

// LinkedHashSet avec capacité et facteur de charge par défaut
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Par défaut,

la capacité du linked hash set sera 16
le facteur de charge sera 0.75

Création de LinkedHashSet depuis d'Autres Collections

Voici comment nous pouvons créer un linked hash set contenant tous les éléments d'autres collections.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        // Création d'un arrayList de nombres pairs
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);
        // Création d'un LinkedHashSet depuis un ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

Sortie

ArrayList: [2, 4] LinkedHashSet: [2, 4]

Méthodes de LinkedHashSet

La classe LinkedHashSet fournit des méthodes permettant diverses opérations sur le linked hash set.

Insérer des Éléments dans LinkedHashSet

add() - insère l'élément spécifié dans le linked hash set
addAll() - insère tous les éléments de la collection spécifiée dans le linked hash set

Par exemple,

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

Sortie

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

Accéder aux Éléments de LinkedHashSet

Pour accéder aux éléments d'un linked hash set, nous pouvons utiliser la méthode iterator(). Pour utiliser cette méthode, nous devons importer le package java.util.Iterator. Par exemple,

import java.util.LinkedHashSet;
import java.util.Iterator;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("LinkedHashSet: " + numbers);
        // Appel de la méthode iterator()
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("LinkedHashSet avec Iterator: ");
        // Accès aux éléments
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Sortie

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

Note :

hasNext() retourne true s'il y a un élément suivant dans le linked hash set
next() retourne l'élément suivant dans le linked hash set

Supprimer des Éléments de HashSet

remove() - supprime l'élément spécifié du linked hash set
removeAll() - supprime tous les éléments du linked hash set

Par exemple,

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

Sortie

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

Opérations sur les Ensembles

Les diverses méthodes de la classe LinkedHashSet peuvent aussi être utilisées pour effectuer diverses opérations sur les ensembles.

Union des Ensembles

Pour effectuer l'union entre deux ensembles, nous pouvons utiliser la méthode addAll(). Par exemple,

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

Sortie

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

Intersection des Ensembles

Pour effectuer l'intersection entre deux ensembles, nous pouvons utiliser la méthode retainAll(). Par exemple

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

Sortie

LinkedHashSet1: [2, 3] LinkedHashSet2: [2, 4] L'intersection est: [2]

Différence des Ensembles

Pour calculer la différence entre les deux ensembles, nous pouvons utiliser la méthode removeAll(). Par exemple,

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

Sortie

LinkedHashSet1: [2, 3, 5] LinkedHashSet2: [1, 3, 5] Différence: [2]

Sous-ensemble

Pour vérifier si un ensemble est un sous-ensemble d'un autre ensemble ou non, nous pouvons utiliser la méthode containsAll(). Par exemple,

import java.util.LinkedHashSet;
class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("LinkedHashSet1: " + numbers);
        LinkedHashSet<Integer> primeNumbers = new LinkedHashSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("LinkedHashSet2: " + primeNumbers);
        // Vérifier si primeNumbers est un sous-ensemble de numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("LinkedHashSet2 est-il un sous-ensemble de LinkedHashSet1? " + result);
    }
}

Sortie

LinkedHashSet1: [1, 2, 3, 4] LinkedHashSet2: [2, 3] LinkedHashSet2 est-il un sous-ensemble de LinkedHashSet1? true

Autres Méthodes de LinkedHashSet

Méthode	Description
`clone()`	Crée une copie du `LinkedHashSet`
`contains()`	Recherche le `LinkedHashSet` pour l'élément spécifié et retourne un résultat booléen
`isEmpty()`	Vérifie si le `LinkedHashSet` est vide
`size()`	Retourne la taille du `LinkedHashSet`
`clear()`	Supprime tous les éléments du `LinkedHashSet`

Pour en savoir plus sur les méthodes LinkedHashSet, visitez la documentation officielle Java LinkedHashSet.

LinkedHashSet vs HashSet

Les deux LinkedHashSet et HashSet implémentent l'interface Set. Cependant, il existe des différences entre eux.

LinkedHashSet maintient une liste chaînée en interne. De ce fait, il maintient l'ordre d'insertion de ses éléments.
La classe LinkedHashSet nécessite plus de stockage que HashSet. C'est parce que LinkedHashSet maintient des listes chaînées en interne.
La performance de LinkedHashSet est plus lente que HashSet. C'est à cause des listes chaînées présentes dans LinkedHashSet.

LinkedHashSet vs TreeSet

Voici les différences majeures entre LinkedHashSet et TreeSet :

La classe TreeSet implémente l'interface SortedSet. C'est pourquoi les éléments dans un tree set sont triés. Cependant, la classe LinkedHashSet ne maintient que l'ordre d'insertion de ses éléments.
Un TreeSet est généralement plus lent qu'un LinkedHashSet. C'est parce que chaque fois qu'un élément est ajouté à un TreeSet, il doit effectuer l'opération de tri.
LinkedHashSet autorise l'insertion de valeurs null. Cependant, nous ne pouvons pas insérer une valeur null dans TreeSet.

Java EnumSet : Création, Opérations et Astuces de Performance Maîtriser Java SortedSet : Guide pratique de TreeSet et de ses méthodes

Java