Java LinkedHashSet

In diesem Tutorial lernen wir die Java-Klasse LinkedHashSet und ihre Methoden anhand von Beispielen kennen.

Der LinkedHashSet Klasse des Java-Collections-Frameworks bietet Funktionalitäten sowohl der Hashtabelle als auch der Linked-List-Datenstruktur.

Es implementiert die Set-Schnittstelle.

Elemente von LinkedHashSet werden ähnlich wie HashSet in Hash-Tabellen gespeichert.

Verknüpfte Hash-Sets führen jedoch intern eine doppelt verknüpfte Liste für alle ihre Elemente. Die verknüpfte Liste definiert die Reihenfolge, in der Elemente in Hash-Tabellen eingefügt werden.

Erstellen Sie ein LinkedHashSet

Um ein verknüpftes Hash-Set zu erstellen, müssen wir den java.util.LinkedHashSet importieren Paket zuerst.

Sobald wir das Paket importiert haben, können wir wie folgt verknüpfte Hash-Sets in Java erstellen.

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

Hier haben wir ein verknüpftes Hash-Set mit dem Namen numbers erstellt .

Beachten Sie den Teil new LinkedHashSet<>(8, 0.75) . Hier ist der erste Parameter Kapazität und der zweite Parameter ist loadFactor .

Kapazität - Die Kapazität dieses Hash-Sets beträgt 8. Das heißt, es kann 8 Elemente speichern.
loadFactor - Der Ladefaktor dieses Hash-Sets beträgt 0,6. Das heißt, immer wenn unsere Hash-Tabelle zu 60 % gefüllt ist, werden die Elemente in eine neue Hash-Tabelle verschoben, die doppelt so groß ist wie die ursprüngliche Hash-Tabelle.

Standardkapazität und Ladefaktor

Es ist möglich, ein verknüpftes Hash-Set zu erstellen, ohne seine Kapazität und seinen Lastfaktor zu definieren. Zum Beispiel

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

Standardmäßig

Die Kapazität des verknüpften Hash-Sets beträgt 16
der Ladefaktor beträgt 0,75

LinkedHashSet aus anderen Sammlungen erstellen

So können wir ein verknüpftes Hash-Set erstellen, das alle Elemente anderer Sammlungen enthält.

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

Ausgabe

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

Methoden von LinkedHashSet

Die LinkedHashSet Die Klasse stellt Methoden bereit, mit denen wir verschiedene Operationen mit dem verknüpften Hash-Set ausführen können.

Elemente in LinkedHashSet einfügen

add() - fügt das angegebene Element in das verknüpfte Hash-Set ein
addAll() - fügt alle Elemente der angegebenen Sammlung in das verknüpfte Hash-Set ein

Zum Beispiel

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

Ausgabe

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

Zugriff auf LinkedHashSet-Elemente

Um auf die Elemente eines verknüpften Hash-Sets zuzugreifen, können wir den iterator() verwenden Methode. Um diese Methode zu verwenden, müssen wir den java.util.Iterator importieren Paket. Zum Beispiel

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(", ");
        }
    }
}

Ausgabe

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

Hinweis :

hasNext() gibt true zurück wenn es ein nächstes Element im verknüpften Hash-Set gibt
next() gibt das nächste Element im verknüpften Hash-Set zurück

Elemente aus HashSet entfernen

remove() - entfernt das angegebene Element aus dem verknüpften Hash-Set
removeAll() - entfernt alle Elemente aus dem verknüpften Hash-Set

Zum Beispiel

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

Ausgabe

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

Set-Operationen

Die verschiedenen Methoden des LinkedHashSet Klasse kann auch verwendet werden, um verschiedene Set-Operationen auszuführen.

Vereinigung von Mengen

Zwei führen die Vereinigung zwischen zwei Mengen durch, wir können den addAll() verwenden Methode. Zum Beispiel

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

Ausgabe

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

Schnittmenge von Mengen

Um die Schnittmenge zwischen zwei Sätzen auszuführen, können wir den retainAll() verwenden Methode. Zum Beispiel

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

Ausgabe

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

Unterschied von Sätzen

Um die Differenz zwischen den beiden Sätzen zu berechnen, können wir den removeAll() verwenden Methode. Zum Beispiel

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

Ausgabe

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

Teilmenge

Um zu überprüfen, ob eine Menge eine Teilmenge einer anderen Menge ist oder nicht, können wir den containsAll() verwenden Methode. Zum Beispiel

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

Ausgabe

LinkedHashSet1: [1, 2, 3, 4]
LinkedHashSet2: [2, 3]
Is LinkedHashSet2 is a subset of LinkedHashSet1? true

Andere Methoden von LinkedHashSet

zurück

Methode	Beschreibung
`clone()`	Erzeugt eine Kopie von `LinkedHashSet`
`contains()`	Sucht den `LinkedHashSet` für das angegebene Element und gibt ein boolesches Ergebnis
`isEmpty()`	Überprüft, ob der `LinkedHashSet` ist leer
`size()`	Gibt die Größe des `LinkedHashSet` zurück
`clear()`	Entfernt alle Elemente aus `LinkedHashSet`

Um mehr über LinkedHashSet zu erfahren Methoden finden Sie unter Java LinkedHashSet (offizielle Java-Dokumentation).

LinkedHashSet vs. HashSet

Beide LinkedHashSet und HashSet implementiert den Set Schnittstelle. Es gibt jedoch einige Unterschiede zwischen ihnen.

LinkedHashSet verwaltet intern eine verknüpfte Liste. Aus diesem Grund behält es die Einfügungsreihenfolge seiner Elemente bei.
Der LinkedHashSet Klasse benötigt mehr Speicherplatz als HashSet . Das liegt daran, dass LinkedHashSet verwaltet intern verlinkte Listen.
Die Leistung von LinkedHashSet ist langsamer als HashSet . Das liegt an verknüpften Listen in LinkedHashSet .

LinkedHashSet Vs. TreeSet

Hier sind die Hauptunterschiede zwischen LinkedHashSet und TreeSet :

Der TreeSet Klasse implementiert den SortedSet Schnittstelle. Deshalb werden Elemente in einem Baumsatz sortiert. Allerdings ist die LinkedHashSet Die Klasse behält nur die Einfügungsreihenfolge ihrer Elemente bei.
A TreeSet ist normalerweise langsamer als ein LinkedHashSet . Dies liegt daran, dass jedes Mal, wenn ein Element zu einem TreeSet hinzugefügt wird , muss es die Sortieroperation durchführen.
LinkedHashSet ermöglicht das Einfügen von Nullwerten. Wir können jedoch keinen Nullwert in TreeSet einfügen .

Java-EnumSet Java-SortedSet-Schnittstelle

Java