Java LinkedHashSet

Ensemble de hachage lié Java

Dans ce didacticiel, nous allons découvrir la classe Java LinkedHashSet et ses méthodes à l'aide d'exemples.

Le LinkedHashSet La classe du framework de collections Java fournit des fonctionnalités à la fois de la table de hachage et de la structure de données de la liste liée.

Il implémente l'interface Set.

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

Cependant, les ensembles de hachage liés conservent une liste à double lien en interne pour tous ses é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

Afin de créer un ensemble de hachage lié, nous devons importer le java.util.LinkedHashSet paquet d'abord.

Une fois le package importé, voici comment créer des ensembles de hachage liés en Java.

// LinkedHashSet with 8 capacity and 0.75 load factor
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Ici, nous avons créé un ensemble de hachage lié nommé numbers .

Remarquez, la partie new LinkedHashSet<>(8, 0.75) . Ici, le premier paramètre est la capacité et le deuxième paramètre est loadFactor .

capacité - La capacité de cet ensemble de hachage est de 8. Cela signifie qu'il peut stocker 8 éléments.
facteur de charge - Le facteur de charge de cet ensemble de hachage est de 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 la taille du double de la table de hachage d'origine.

Capacité et facteur de charge par défaut

Il est possible de créer un ensemble de hachage lié sans définir sa capacité et son facteur de charge. Par exemple,

// LinkedHashSet with default capacity and load factor
LinkedHashSet<Integer> numbers1 = new LinkedHashSet<>();

Par défaut,

la capacité de l'ensemble de hachage lié sera de 16
le facteur de charge sera de 0,75

Création d'un LinkedHashSet à partir d'autres collections

Voici comment nous pouvons créer un ensemble de hachage lié contenant tous les éléments des autres collections.

import java.util.LinkedHashSet;
import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an arrayList of even numbers
        ArrayList<Integer> evenNumbers = new ArrayList<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("ArrayList: " + evenNumbers);

        // Creating a LinkedHashSet from an ArrayList
        LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
        System.out.println("LinkedHashSet: " + numbers);
    }
}

Sortie

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

Méthodes de LinkedHashSet

Le LinkedHashSet fournit des méthodes qui nous permettent d'effectuer diverses opérations sur le jeu de hachage lié.

Insérer des éléments dans LinkedHashSet

add() - insère l'élément spécifié dans le jeu de hachage lié
addAll() - insère tous les éléments de la collection spécifiée dans le jeu de hachage lié

Par exemple,

import java.util.LinkedHashSet;

class Main {
    public static void main(String[] args) {
        LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();

        // Using add() method
        evenNumber.add(2);
        evenNumber.add(4);
        evenNumber.add(6);
        System.out.println("LinkedHashSet: " + evenNumber);

        LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
        
        // Using addAll() method
        numbers.addAll(evenNumber);
        numbers.add(5);
        System.out.println("New LinkedHashSet: " + numbers);
    }
}

Sortie

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

Accéder aux éléments LinkedHashSet

Pour accéder aux éléments d'un ensemble de hachage lié, nous pouvons utiliser le iterator() méthode. Pour utiliser cette méthode, nous devons importer le java.util.Iterator forfait. 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);

        // Calling the iterator() method
        Iterator<Integer> iterate = numbers.iterator();

        System.out.print("LinkedHashSet using Iterator: ");

        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Sortie

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

Remarque :

hasNext() renvoie true s'il y a un élément suivant dans le jeu de hachage lié
next() renvoie l'élément suivant dans le jeu de hachage lié

Supprimer des éléments du HashSet

remove() - supprime l'élément spécifié du jeu de hachage lié
removeAll() - supprime tous les éléments du jeu de hachage lié

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);

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

Sortie

LinkedHashSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Définir les opérations

Les différentes méthodes du LinkedHashSet La classe peut également être utilisée pour effectuer diverses opérations d'ensemble.

Union d'ensembles

Deux font l'union entre deux ensembles, on peut utiliser le addAll() méthode. 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 of two set
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);
    }
}

Sortie

LinkedHashSet1: [2, 4]
LinkedHashSet2: [1, 3]
Union is: [1, 3, 2, 4]

Intersection d'ensembles

Pour effectuer l'intersection entre deux ensembles, on peut utiliser le retainAll() méthode. 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 of two sets
        evenNumbers.retainAll(primeNumbers);
        System.out.println("Intersection is: " + evenNumbers);
    }
}

Sortie

LinkedHashSet1: [2, 3]
LinkedHashSet2: [2, 4]
Intersection is: [2]

Différence des ensembles

Pour calculer la différence entre les deux ensembles, nous pouvons utiliser le removeAll() méthode. 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);

        // Difference between LinkedHashSet1 and LinkedHashSet2
        primeNumbers.removeAll(oddNumbers);
        System.out.println("Difference : " + primeNumbers);
    }
}

Sortie

LinkedHashSet1: [2, 3, 5]
LinkedHashSet2: [1, 3, 5]
Difference: [2]

Sous-ensemble

Pour vérifier si un ensemble est un sous-ensemble d'un autre ensemble ou non, on peut utiliser le containsAll() méthode. 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);

        // Check if primeNumbers is a subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is LinkedHashSet2 is subset of LinkedHashSet1? " + result);
    }
}

Sortie

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
Is LinkedHashSet2 is a subset of 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 renvoie un résultat booléen
`isEmpty()`	Vérifie si le `LinkedHashSet` est vide
`size()`	Renvoie la taille du `LinkedHashSet`
`clear()`	Supprime tous les éléments du `LinkedHashSet`

Pour en savoir plus sur LinkedHashSet méthodes, visitez Java LinkedHashSet (documentation officielle de Java).

LinkedHashSet contre. Ensemble de hachage

Les deux LinkedHashSet et HashSet implémente le Set interface. Cependant, il existe quelques différences entre eux.

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

LinkedHashSet contre. ArbreEnsemble

Voici les principales différences entre LinkedHashSet et TreeSet :

Le TreeSet la classe implémente le SortedSet interface. C'est pourquoi les éléments d'un ensemble d'arbres sont triés. Cependant, le LinkedHashSet la classe ne conserve 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 permet l'insertion de valeurs nulles. Cependant, nous ne pouvons pas insérer une valeur nulle dans TreeSet .

Java EnumSet Interface Java SortedSet

Java