LinkedHashSet in Java

Wenn wir über die LinkedHashSet- Klasse in Java sprechen, müssen wir erwähnen, dass sie die Set- Schnittstelle implementiert. LinkedHashSet erstellt eine Sammlung, die Elemente in einer Hash-Tabelle speichert, aber im Gegensatz zum HashSet- Gegenstück die Einfügereihenfolge der Elemente beibehält .

Was ist in Java festgelegt?

Erinnern wir uns kurz daran, dass die Set- Schnittstelle eine Menge (Set) definiert. Es erweitert Collection und definiert das Verhalten von Sammlungen, die keine doppelten Elemente zulassen. Daher gibt die Methode add() false zurück , wenn versucht wird, der Menge ein doppeltes Element hinzuzufügen. Die Schnittstelle definiert keine weiteren eigenen Methoden. Die Set- Schnittstelle kümmert sich um die Einzigartigkeit gespeicherter Objekte. Die Einzigartigkeit wird durch die Implementierung der Methode equal() bestimmt . Wenn daher Objekte der erstellten Klasse zum Set hinzugefügt werden , ist es wünschenswert, die Methode equal() zu überschreiben.

LinkedHashSet-Klasse

Bevor wir über die LinkedHashSet- Klasse sprechen, müssen wir ihren nahen Verwandten, die HashSet- Klasse, erwähnen. HashSet implementiert die Set- Schnittstelle. Es erstellt eine Sammlung, die die Elemente in einer Hash-Tabelle speichert. Die Elemente einer Hash-Tabelle werden als Schlüssel-Wert-Paare gespeichert. Der Schlüssel gibt die Zelle (oder das Segment) an, in der der Wert gespeichert werden soll. Der Inhalt des Schlüssels wird verwendet, um einen eindeutigen Wert zu ermitteln, der als Hash-Code bezeichnet wird. Wir können uns einen Hash-Code als eine Objektkennung vorstellen, obwohl er nicht eindeutig sein muss. Dieser Hash-Code dient auch als Index, in dem die mit dem Schlüssel verbundenen Daten gespeichert werden. Die Java-Klasse LinkedHashSet erweitert HashSet , ohne neue Methoden hinzuzufügen.Mit LinkedHashSet können Sie wie HashSet schnell prüfen, ob ein Eintrag vorhanden ist , es enthält jedoch eine geordnete Liste. Dies bedeutet, dass die Einfügereihenfolge der Elemente gespeichert wird. Mit anderen Worten: LinkedHashSet verwaltet eine verknüpfte Liste von Set-Elementen in der Reihenfolge, in der sie eingefügt wurden. Dies ermöglicht eine geordnete Iteration des Einfügens in eine Menge. Dies führt jedoch dazu, dass die LinkedHashSet- Klasse Vorgänge länger ausführt als die HashSet- Klasse.

Wichtige Funktionen von LinkedHashSet

Wir können eindeutige Elemente nur in einem LinkedHashSet speichern
Mit LinketHashSet können wir Elemente in derselben Reihenfolge extrahieren, in der wir sie einfügen
LinkedHashSet ist nicht synchronisiert
LinkedHashSet ermöglicht das Speichern von Nullelementen
LinkedHashSet verwendet eine Hashing-Technik, um Elemente basierend auf einem Hash-Code an einem angegebenen Index zu speichern

LinkedHashSet-Methoden

Zusätzlich zu den von seinen übergeordneten Klassen geerbten Methoden definiert HashSet die folgenden Methoden:

boolean add(Object o) fügt das angegebene Element zu dieser Menge hinzu, wenn es noch nicht vorhanden ist.
void clear() entfernt alle Elemente aus dieser Menge.
Object clone() gibt eine flache Kopie dieser LinkedHashSet- Instanz zurück: Die Elemente selbst werden nicht geklont.
boolean contains(Object o) gibt true zurück, wenn diese Menge das angegebene Element enthält.
boolean isEmpty() gibt true zurück , wenn diese Menge keine Elemente enthält.
Iterator iterator() gibt einen Iterator über die Elemente dieser Menge zurück.
boolean remove(Object o) entfernt das angegebene Element aus dieser Menge, falls vorhanden.
int size() gibt die Anzahl der Elemente in dieser Menge (ihre Anzahl an Elementen) zurück.

Einfache LinkedHashSet-Beispiele Im folgenden Beispiel zeigen wir die Initialisierung des LinkedHashSet- Objekts und die Verwendung der add()- Methode zum Ausfüllen des Satzes.


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

Die Ausgabe ist:

[Re, Do, Fa, Sol, La, Ti, Mi]

Wie Sie sehen können, erschienen die Elemente in unserem Set in der gleichen Reihenfolge, in der wir sie platziert hatten.

Beispiel 2. Hinzufügen eines Duplikats zu LinkedHashSet

Fügen wir erneut unsere LinkedHashSet 7-Elemente mit Namen von Musikpartituren ein und fügen wir ein neues Element ein, das mit einem der zuvor platzierten Elemente identisch ist.


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

Die Ausgabe des Programms ist hier:

[Re, Do, Fa, Sol, La, Ti, Mi]

Die Ausgabe von Beispiel zwei ist genau die gleiche wie im ersten Beispiel. Wir können nicht zwei ähnliche Elemente in der LinkedHashSet- Sammlung haben. Wenn wir versuchen, das zweite zu platzieren, wird es einfach ignoriert.

Beispiel 3. Elemente aus LinkedHashSet entfernen


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

Die Ausgabe des Programms ist hier:

[Re, Do, Fa, Sol, La, Ti, Mi] false Drucken Sie unseren Satz ohne entfernte Elemente aus: [Re, Do, Sol, La, Ti, Mi] Drucken Sie unseren Satz nach dem Clear-Befehl aus: []

Wie Sie sehen, führt die Anwendung der Methode „remove()“ auf ein nicht vorhandenes Element nicht zu einem Programmfehler. Es gibt einfach „false“ zurück , wenn das Element nicht entfernt wurde, und „ true“ , wenn das Element im LinkedHashSet war und dann entfernt wurde.

LinkedHashSet vs. HashSet

Diese beiden Klassen sind enge Verwandte. Innerhalb des HashSet wird jedoch HashMap zum Speichern von Objekten verwendet , während LinkedHashSet LinkedHashMap verwendet . Wenn Sie die Einfügereihenfolge nicht beibehalten, aber eindeutige Objekte speichern müssen, ist die Verwendung von HashSet besser geeignet . Wenn Sie die Einfügereihenfolge von Elementen beibehalten müssen, ist LinkedHashSet Ihre Wahl. Die Leistung von LinkedHashSet ist etwas langsamer als die von HashSet , da LinkedHashSet interne LinkedList verwendet , um die Einfügereihenfolge von Elementen beizubehalten. Nehmen wir ein Beispiel:


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

Die Ausgabe des Programms ist:

RegularHashSet = [65536, 3, 5, 7, 9] LinkedHashSet = [7, 3, 5, 65536, 9]

Verwendung von Java LinkedHashSet in realen Anwendungen

Da Sie mit LinkedHashSet schnell prüfen können, ob ein Eintrag vorhanden ist, und auch die Reihenfolge speichert, scheint diese Sammlung recht praktisch zu sein, um Duplikate aus einer Liste zu entfernen. Oder zum Beispiel das Lösen von Problemen wie dem zuletzt gesehenen Gegenstand in meiner Tasche. Oder erinnern Sie sich an ein solches Spiel, Pokemon Go? LinkedHashSet kann eine Liste der Pokémon speichern, denen Sie begegnet sind, sowie die Reihenfolge, in der sie Ihnen auf Ihrem Weg begegnet sind. In diesem Fall wird das „wiederholte“ Pokémon nicht mehr zur Liste hinzugefügt. Oder zum Beispiel eine Liste der Bosse nach Level, die Sie bereits in einem Spiel mit Levels getroffen haben. Oder die Geschichte der Entdeckung kosmischer Körper. LinkedHashSetermöglicht es Ihnen, schnell zu überprüfen, ob ein Raumkörper bereits in der Liste vorhanden ist oder nicht. Wenn er nicht vorhanden ist, können Sie ihn zur Liste hinzufügen. Nehmen wir ein Beispiel für die Beseitigung von Duplikaten.


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

Die Ausgabe des Programms ist hier:

listWithDuplicates = [einige Elemente mit wenigen Duplikaten waren hier Duplikate] listWithoutDuplicates = [einige Elemente mit wenigen Duplikaten waren hier] LinkedInHashSet = [einige Elemente mit wenigen Duplikaten , were, hier] regularHashSet = [here, some, with, Duplikate, were, elements, wenigen]