Java LinkedHashSet

In diesem Tutorial werden wir durch Beispiele lernen, wie man die Klasse LinkedHashSet von Java und ihre Methoden verwendet.

Die Klasse LinkedHashSet der Java Collection-Framework bietet die Funktionen von Hash-Tabelle und verknüpfter Liste.

es implementiertSet-Schnittstelle.

Die Elemente des LinkedHashSet werden in einer ähnlichenDie HashSetin der Hash-Tabelle.

Allerdings führt die Listen-Hash-Sammel intern für alle ihre Elemente eine doppelte Liste. Die Liste definiert die Reihenfolge der Elemente in der Hash-Tabelle.

Erstellen Sie eine LinkedHashSet

Um eine Listen-Hash-Sammel zu erstellen, müssen wir zunächst das Paket java.util.LinkedHashSet importieren.

Nach dem Importieren des Pakets können Sie in Java eine Listen-Hash-Sammel erstellen.

//mit8und einer Kapazität von 0.75LinkedHashSet mit Lastfaktor
LinkedHashSet<Integer> numbers = new LinkedHashSet<>(8, 0.75);

Hierbei erstellen wir eine als numbers bezeichnete Liste-Hash-Sammel.

Beachten Sie, dass der Ausdruck new LinkedHashSet<>(8, 0.75) Hierbei ist der erste ParameterKapazität, der zweite Parameter istLastfaktor.

• capacity - Die Kapazität dieses Hash-Sets beträgt8Dies bedeutet, dass es speichern kann8Elemente.

• loadFactor- Die Lastfaktor dieses Hash-Sets beträgt 0.6Dies bedeutet, dass, sobald unser Hash-Table gefüllt ist60%, der Elemente wird in den neuen Hash-Table verschoben, deren Größe doppelt so groß ist wie die des ursprünglichen Hash-Tables.

Standardkapazität und Ladefaktor

Ein LinkedHashSet der Liste kann ohne Definition seiner Kapazität und seines Ladefaktors erstellt werden. Zum Beispiel:

//LinkedHashSet mit Standardkapazität und Ladefaktor
LinkedHashSet<Integer> numbers1　= new LinkedHashSet<>();

Standardmäßig,

• Die Kapazität des LinkedHashSet der Liste wird sein16

• Der Ladefaktor wird 0 sein.75

Erstellen eines LinkedHashSet aus anderen Sammlungen

Dies ist, wie wir einen LinkedHashSet erstellen, der alle Elemente anderer Sets enthält.

import java.util.LinkedHashSet;
import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen eines ArrayLists für die geraden Zahlen
　　　　　　　　ArrayList<Integer> evenNumbers = new ArrayList<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("ArrayList: ",　+　evenNumbers);
　　　　　　　　//Erstellen eines LinkedHashSet aus einem ArrayList
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>(evenNumbers);
　　　　　　　　System.out.println("LinkedHashSet: ");　+　numbers);
　　　　}
}

Ausgaberesultat

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

Methoden des LinkedHashSet

Die Klasse LinkedHashSet bietet verschiedene Methoden, um verschiedene Operationen auf dem HashSet der Liste auszuführen.

Fügen Sie das Element in das LinkedHashSet ein

• add() - Fügen Sie das angegebene Element in das HashSet der Liste ein

• addAll() - Fügen Sie alle Elemente des angegebenen Sets in das HashSet der Liste ein

Zum Beispiel

import java.util.LinkedHashSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedHashSet<Integer> evenNumber = new LinkedHashSet<>();
　　　　　　　　//　Verwendung der Methode add()
　　　　　　　　evenNumber.add(2);
　　　　　　　　evenNumber.add(4);
　　　　　　　　evenNumber.add(6);
　　　　　　　　System.out.println("LinkedHashSet: ");　+　evenNumber);
　　　　　　　　LinkedHashSet<Integer> numbers = new LinkedHashSet<>();
　　　　　　　　
　　　　　　　　//Verwendung der Methode addAll()
　　　　　　　　numbers.addAll(evenNumber);
　　　　　　　　numbers.add(5);
　　　　　　　　System.out.println("Neues LinkedHashSet: ",　+　numbers);
　　　　}
}

Ausgaberesultat

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

Zugriff auf die Elemente des LinkedHashSet

Um die Elemente des HashSets der Liste zu erreichen, können wir die Methode iterator() verwenden. Um diese Methode nutzen zu können, müssen wir das Paket java.util.Iterator importieren. 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);
　　　　　　　　//Aufruf der Methode iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("Verwenden Sie LinkedHashSet mit Iterator: ");
　　　　　　　　//Elemente aufrufen
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Ausgaberesultat

LinkedHashSet: [2,　5,　6]
Verwenden Sie LinkedHashSet mit Iterator:　2,　5,　6,

Hinweise:

• hasNext() gibt zurück, ob im Hash-Speicher des Links ein nächstes Element existiert

• next() gibt den nächsten Element im Hash-Speicher des Links zurück

Elemente aus dem HashSet löschen

• remove() - Spezifische Elemente aus dem Hash-Speicher der Liste löschen

• removeAll() - Alle Elemente aus dem Hash-Speicher der Liste löschen

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);
　　　　　　　　//Verwenden Sie die Methode remove()
　　　　　　　　boolean value1　= numbers.remove(5);
　　　　　　　　System.out.println("5Gelöscht worden? \　+　value1);
　　　　　　　　boolean value2　= numbers.removeAll(numbers);
　　　　　　　　System.out.println("Sind alle Elemente gelöscht worden? ");　+　value2);
　　　　}
}

Ausgaberesultat

LinkedHashSet: [2,　5,　6]
5Gelöscht worden? true
Sind alle Elemente gelöscht worden? true

LinkedHashSet-Operationen

Die verschiedenen Methoden der Klasse LinkedHashSet können auch zur Ausführung verschiedener Set-Operationen verwendet werden.

Union

Um die Union zwischen zwei Mengen auszuführen, können wir die Methode addAll() verwenden. 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);
　　　　　　　　//Die Union zweier Mengen
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Union: ");　+　numbers);
　　　　}
}

Ausgaberesultat

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

Schnitt

Um den Schnitt zwischen zwei Mengen auszuführen, können wir die Methode retainAll() verwenden. 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);
　　　　　　　　//Der Schnitt der Mengen
　　　　　　　　evenNumbers.retainAll(primeNumbers);
　　　　　　　　System.out.println("Der Schnitt der Mengen: ");　+　evenNumbers);
　　　　}
}

Ausgaberesultat

LinkedHashSet1: [2,　3]
LinkedHashSet2: [2,　4]
Der Schnitt der Mengen: [2]

Differenzmenge

Um den Unterschied zwischen zwei Mengen zu berechnen, können wir die Methode removeAll() verwenden. 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);
　　　　　　　　//LinkedHashSet1und LinkedHashSet2Differenzmenge zwischen
　　　　　　　　primeNumbers.removeAll(oddNumbers);
　　　　　　　　System.out.println("Differenzmenge: "　+　primeNumbers);
　　　　}
}

Ausgaberesultat

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

Teilmenge

Um zu überprüfen, ob eine Sammlung eine Teilmenge einer anderen Sammlung ist, können wir den containsAll()-Methodenaufruf verwenden. 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);
　　　　　　　　//Überprüfen, ob primeNumbers eine Teilmenge von numbers ist
　　　　　　　　boolean result = numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("LinkedHashSet2Ist LinkedHashSet1Ist das eine Teilmenge? "　+　result);
　　　　}
}

Ausgaberesultat

LinkedHashSet1: [1,　2,　3,　4]
LinkedHashSet2: [2,　3]
LinkedHashSet2Ist LinkedHashSet1Ist das eine Teilmenge? true

Andere Methoden von LinkedHashSet

Unterschiede zwischen LinkedHashSet und HashSet

LinkedHashSet und HashSet implementieren das Set-Interface. Allerdings gibt es zwischen ihnen einige Unterschiede.

• LinkedHashSet unterhält intern eine Liste. Daher behält es die Reihenfolge der Elemente der Eintragung bei.

• LinkedHashSet benötigt mehr Speicherplatz als HashSet. Dies liegt daran, dass LinkedHashSet intern eine Liste unterhält.

• Die Leistung von LinkedHashSet ist langsamer als die von HashSet. Dies liegt daran, dass es in LinkedHashSet eine Liste gibt.

Unterschiede zwischen LinkedHashSet und TreeSet

Hier sind die Hauptunterschiede zwischen LinkedHashSet und TreeSet:

• Die TreeSet-Klasse implementiert das SortedSet-Interface. Dies ist der Grund, warum die Elemente in der Baumansammlung sortiert sind. Aber die LinkedHashSet-Klasse unterhält nur die Reihenfolge der Elemente der Eintragung.

• TreeSet ist im Allgemeinen langsamer als LinkedHashSet. Dies liegt daran, dass TreeSet bei jedem Hinzufügen eines Elements eine Sortieroperation durchführen muss.

• LinkedHashSet ermöglicht den Eintrag von Nullwerten. Wir können jedoch keine Nullwerte in TreeSet einfügen.