LinkedHashSet en Java

En parlant de la classe LinkedHashSet en Java, nous devons mentionner qu'elle implémente l' interface Set . LinkedHashSet crée une collection qui stocke des éléments dans une table de hachage mais conserve l'ordre d'insertion des éléments contrairement à son homologue HashSet .

Ce qui est défini en Java

Rappelons brièvement que l' interface Set définit un ensemble (set). Il étend Collection et définit le comportement des collections qui n'autorisent pas les éléments en double. Ainsi, la méthode add() renvoie false si une tentative est faite pour ajouter un élément dupliqué à l'ensemble. L'interface ne définit pas de méthodes supplémentaires qui lui sont propres. L' interface Set s'occupe de l'unicité des objets stockés, l'unicité est déterminée par l'implémentation de la méthode equals() . Par conséquent, si des objets de la classe créée seront ajoutés au Set , il est souhaitable de remplacer la méthode equals() .

Classe LinkedHashSetLinkedHashSet class

Avant de parler de la classe LinkedHashSet , nous devons mentionner son proche parent, la classe HashSet . HashSet implémente l' interface Set . Il crée une collection qui stocke les éléments dans une table de hachage. Les éléments d'une table de hachage sont stockés sous forme de paires clé-valeur. La clé spécifie la cellule (ou le segment) pour stocker la valeur. Le contenu de la clé est utilisé pour déterminer une valeur unique appelée code de hachage. Nous pouvons considérer un code de hachage comme un identifiant d'objet, même s'il n'est pas nécessaire qu'il soit unique. Ce code de hachage sert également d'index dans lequel les données associées à la clé sont stockées. La classe Java LinkedHashSet étend HashSet sans ajouter de nouvelles méthodes.LinkedHashSet vous permet de vérifier rapidement l'existence d'une entrée, tout comme HashSet , mais contient une liste ordonnée à l'intérieur. Cela signifie qu'il stocke l'ordre d'insertion des éléments. En d'autres termes, LinkedHashSet maintient une liste chaînée d'éléments d'ensemble dans l'ordre dans lequel ils ont été insérés. Cela permet une itération ordonnée de l'insertion dans un ensemble. Mais cela amène la classe LinkedHashSet à effectuer des opérations plus longues que la classe HashSet .

Caractéristiques importantes de LinkedHashSet

Nous ne pouvons stocker des éléments uniques que dans un LinkedHashSet
LinketHashSet nous permet d'extraire les éléments dans le même ordre que nous insérons
LinkedHashSet n'est pas synchronisé
LinkedHashSet permet de stocker des éléments nuls
LinkedHashSet utilise une technique de hachage pour stocker des éléments à un index spécifié basé sur un code de hachage

Méthodes LinkedHashSetLinkedHashSet Methods

En plus des méthodes héritées de ses classes parentes, HashSet définit les méthodes suivantes :

boolean add(Object o) ajoute l'élément spécifié à cet ensemble s'il n'est pas déjà présent.
void clear() supprime tous les éléments de cet ensemble.
Object clone() renvoie une copie superficielle de cette instance de LinkedHashSet : les éléments eux-mêmes ne sont pas clonés.
boolean contains(Object o) renvoie true si cet ensemble contient l'élément spécifié.
boolean isEmpty() renvoie true si cet ensemble ne contient aucun élément.
Iterator iterator() renvoie un itérateur sur les éléments de cet ensemble.
boolean remove(Object o) supprime l'élément spécifié de cet ensemble, s'il est présent.
int size() renvoie le nombre d'éléments dans cet ensemble (son nombre d'éléments).

Exemples faciles de LinkedHashSet Dans l'exemple ci-dessous, nous montrons l'initialisation de l' objet LinkedHashSet et l'utilisation de la méthode add() pour remplir l'ensemble.

import java.util.LinkedHashSet;
import java.util.Set;

   public class LinkedHashSetEx1 {
       public static void main(String[] args) {
//LinkedHashSet() Init
Set<String> set = new LinkedHashSet<>();
//adding elements to LinkedHashSet
           set.add("Re"); //first added element
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");//last added element


           System.out.println(set);
       }
   }

La sortie est :

[Ré, Do, Fa, Sol, La, Ti, Mi]

Comme vous pouvez le voir, les éléments de notre ensemble sont apparus dans le même ordre que nous les avons placés.

Exemple 2. Ajout d'un doublon dans LinkedHashSet

Mettons à nouveau nos éléments LinkedHashSet 7 avec les noms des partitions musicales et mettons un nouvel élément qui est le même que l'un des éléments placés auparavant.

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetEx2 {
   public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           set.add("Sol");
           System.out.println(set);
       }
   }

La sortie du programme est ici :

[Ré, Do, Fa, Sol, La, Ti, Mi]

La sortie de l'exemple deux est exactement la même que dans le premier exemple. Nous ne pouvons pas avoir deux éléments similaires dans la collection LinkedHashSet . Lorsque nous essayons de mettre le second, il est simplement ignoré.

Exemple 3. Suppression d'éléments de LinkedHashSet

import java.util.LinkedHashSet;
import java.util.Set;
   public class LinkedHashSet3 {
       public static void main(String[] args) {
           Set<String> set = new LinkedHashSet<>();
           set.add("Re");
           set.add("Do");
           set.add("Fa");
           set.add("Sol");
           set.add("La");
           set.add("Ti");
           set.add("Mi");
           System.out.println(set);
           set.remove("Fa");// removing an element from our set
           set.remove("Score");//trying to remove element that isn't in set
           System.out.println(set.remove("Score"));
           System.out.println("Print our set without elements removed: ");
           System.out.println(set);
           set.clear();
           System.out.println("Print out our set after clear command: ");
           System.out.println(set);
       }
   }

La sortie du programme est ici :

[Re, Do, Fa, Sol, La, Ti, Mi] false Imprimer notre ensemble sans éléments supprimés : [Re, Do, Sol, La, Ti, Mi] Imprimer notre ensemble après la commande clear : []

Comme vous pouvez le voir, la méthode remove() appliquée à un élément inexistant n'entraîne pas d'erreur de programme. Il renvoie simplement false si l'élément n'a pas été supprimé et true si l'élément était dans le LinkedHashSet puis supprimé.

LinkedHashSet contre HashSet

Ces deux classes sont proches. Cependant, à l'intérieur du HashSet , il utilise HashMap pour stocker des objets tandis que LinkedHashSet utilise LinkedHashMap . Si vous n'avez pas besoin de conserver l'ordre d'insertion mais que vous devez stocker des objets uniques, il est plus approprié d'utiliser HashSet . Si vous devez conserver l'ordre d'insertion des éléments, LinkedHashSet est votre choix. Les performances de LinkedHashSet sont un peu plus lentes que celles de HashSet car LinkedHashSet utilise une LinkedList interne pour maintenir l'ordre d'insertion des éléments. Prenons un exemple :

import java.util.*;

public class LinkedHashSetExample1 {

   public static void main(String[] args) {
       // while regular hash set orders its elements according to its hashcode stamps

       Set<Integer> regularHashSet = new HashSet<>();
       regularHashSet.add(7);
       regularHashSet.add(3);
       regularHashSet.add(5);
       regularHashSet.add(65536);
       regularHashSet.add(9);
       // few duplicates
       regularHashSet.add(5);
       regularHashSet.add(7);

       // next will print:
       // > regularHashSet = [65536, 3, 5, 7, 9]
       System.out.println("regularHashSet = " + regularHashSet);

       // linked hash set keeps order of adding unchanged

       Set<Integer> linkedHashSet = new LinkedHashSet<>();
       linkedHashSet.add(7);
       linkedHashSet.add(3);
       linkedHashSet.add(5);
       linkedHashSet.add(65536);
       linkedHashSet.add(9);
       // few duplicates
       linkedHashSet.add(5);
       linkedHashSet.add(7);

       // next will print:
       // > linkedHashSet = [7, 3, 5, 65536, 9]
       System.out.println("linkedHashSet = " + linkedHashSet);
   }
}

La sortie du programme est :

regularHashSet = [65536, 3, 5, 7, 9] linkedHashSet = [7, 3, 5, 65536, 9]

Utilisation de Java LinkedHashSet dans des applications du monde réel

Étant donné que LinkedHashSet vous permet de vérifier rapidement l'existence d'une entrée et également de stocker l'ordre, cette collection semble être assez pratique pour éliminer les doublons d'une liste. Ou, par exemple, résoudre des problèmes comme le dernier article récemment vu dans mon sac. Ou, souvenez-vous d'un tel jeu, Pokemon Go ? LinkedHashSet peut stocker une liste de Pokémon que vous avez rencontrés et l'ordre dans lequel ils sont tombés sur votre chemin. Dans ce cas, les Pokémon "répétés" ne seront plus ajoutés à la liste. Ou, par exemple, une liste de boss par niveau que vous avez déjà rencontrés dans n'importe quel jeu à niveaux. Ou l'histoire de la découverte des corps cosmiques. LinkedHashSetvous permet de vérifier rapidement si un corps spatial est déjà dans la liste ou non, et s'il n'y est pas, ajoutez-le à la liste. Prenons un exemple d'élimination des doublons.

import java.util.*;

class LinkedHashSetExample2 {
   public static void main(String[] args) {
       List<String> listWithDuplicates = List.of("some","elements","with", "few", "duplicates", "were", "here", "duplicates", "duplicates");

       Set<String> linkedHashSet = new LinkedHashSet<>(listWithDuplicates);
       List<String> listWithoutDuplicates = new ArrayList<>(linkedHashSet);

       // next will print:
       // > listWithDuplicates = [some, elements, with, few, duplicates, here, duplicates, duplicates]
       System.out.println("listWithDuplicates = " + listWithDuplicates);
       // next will print:
       // > listWithoutDuplicates = [some, elements, with, few, duplicates, here]
       System.out.println("listWithoutDuplicates = " + listWithoutDuplicates);

       // -------------------------------------------------------------------------

       // while using regular Hash Set will generally produces some unexpected order
       Set<String> regularHashSet = new HashSet<>(listWithDuplicates);

       // next will print:
       // > linkedHashSet = [some, elements, with, few, duplicates, were, here]
       System.out.println("linkedHashSet = " + linkedHashSet);
       // next will print:
       // > regularHashSet = [here, some, with, duplicates, were, elements, few]
       System.out.println("regularHashSet = " + regularHashSet);
   }
}

La sortie du programme est ici :

listWithDuplicates = [certains, éléments, avec, peu, doublons, étaient, ici, doublons, doublons] listWithoutDuplicates = [certains, éléments, avec, peu, doublons, étaient, ici] linkedHashSet = [certains, éléments, avec, peu, doublons , étaient, ici] regularHashSet = [ici, certains, avec, doublons, étaient, éléments, peu]