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).
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 :

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 :
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 :
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 :
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 :
GO TO FULL VERSION