Java-HashSet-Klasse
Java-HashSet-Klasse
In diesem Tutorial lernen wir die Java HashSet-Klasse kennen. Anhand von Beispielen lernen wir verschiedene Hash-Set-Methoden und -Operationen kennen.
Der HashSet -Klasse des Java-Collections-Frameworks stellt die Funktionalitäten der Hash-Tabellen-Datenstruktur bereit.
Es implementiert die Set-Schnittstelle.
HashSet erstellen
Um ein Hash-Set zu erstellen, müssen wir den java.util.HashSet importieren Paket zuerst.
Sobald wir das Paket importiert haben, können wir Hash-Sets in Java wie folgt erstellen.
// HashSet with 8 capacity and 0.75 load factor
HashSet<Integer> numbers = new HashSet<>(8, 0.75);
Hier haben wir ein Hash-Set mit dem Namen numbers erstellt .
Beachten Sie, der Teil neu HashSet<>(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 unser Hash-Set 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, eine Hash-Tabelle zu erstellen, ohne deren Kapazität und Lastfaktor zu definieren. Zum Beispiel
// HashSet with default capacity and load factor
HashSet<Integer> numbers1 = new HashSet<>();
Standardmäßig
- Die Kapazität des Hash-Sets beträgt 16
- der Ladefaktor beträgt 0,75
Methoden von HashSet
Die HashSet Die Klasse stellt verschiedene Methoden bereit, mit denen wir verschiedene Operationen am Set ausführen können.
Elemente in HashSet einfügen
add()- fügt das angegebene Element in die Menge einaddAll()- fügt alle Elemente der angegebenen Sammlung in die Menge ein
Zum Beispiel
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumber = new HashSet<>();
// Using add() method
evenNumber.add(2);
evenNumber.add(4);
evenNumber.add(6);
System.out.println("HashSet: " + evenNumber);
HashSet<Integer> numbers = new HashSet<>();
// Using addAll() method
numbers.addAll(evenNumber);
numbers.add(5);
System.out.println("New HashSet: " + numbers);
}
}
Ausgabe
HashSet: [2, 4, 6] New HashSet: [2, 4, 5, 6]
Zugriff auf HashSet-Elemente
Um auf die Elemente eines 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.HashSet;
import java.util.Iterator;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("HashSet: " + numbers);
// Calling iterator() method
Iterator<Integer> iterate = numbers.iterator();
System.out.print("HashSet using Iterator: ");
// Accessing elements
while(iterate.hasNext()) {
System.out.print(iterate.next());
System.out.print(", ");
}
}
}
Ausgabe
HashSet: [2, 5, 6] HashSet using Iterator: 2, 5, 6,
Elemente entfernen
remove()- entfernt das angegebene Element aus der MengeremoveAll()- entfernt alle Elemente aus der Menge
Zum Beispiel
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(2);
numbers.add(5);
numbers.add(6);
System.out.println("HashSet: " + numbers);
// Using 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
HashSet: [2, 5, 6] Is 5 removed? true Are all elements removed? true
Operationen festlegen
Die verschiedenen Methoden des HashSet Klasse kann auch verwendet werden, um verschiedene Set-Operationen auszuführen.
Vereinigung von Mengen
Um die Vereinigung zwischen zwei Mengen durchzuführen, können wir den addAll() verwenden Methode. Zum Beispiel
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet1: " + evenNumbers);
HashSet<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(3);
System.out.println("HashSet2: " + numbers);
// Union of two set
numbers.addAll(evenNumbers);
System.out.println("Union is: " + numbers);
}
}
Ausgabe
HashSet1: [2, 4] HashSet2: [1, 3] Union is: [1, 2, 3, 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.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
System.out.println("HashSet1: " + primeNumbers);
HashSet<Integer> evenNumbers = new HashSet<>();
evenNumbers.add(2);
evenNumbers.add(4);
System.out.println("HashSet2: " + evenNumbers);
// Intersection of two sets
evenNumbers.retainAll(primeNumbers);
System.out.println("Intersection is: " + evenNumbers);
}
}
Ausgabe
HashSet1: [2, 3] HashSet2: [2, 4] Intersection is: [2]
Unterschied von Mengen
Um die Differenz zwischen den beiden Sätzen zu berechnen, können wir den removeAll() verwenden Methode. Zum Beispiel
import java.util.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
primeNumbers.add(5);
System.out.println("HashSet1: " + primeNumbers);
HashSet<Integer> oddNumbers = new HashSet<>();
oddNumbers.add(1);
oddNumbers.add(3);
oddNumbers.add(5);
System.out.println("HashSet2: " + oddNumbers);
// Difference between HashSet1 and HashSet2
primeNumbers.removeAll(oddNumbers);
System.out.println("Difference : " + primeNumbers);
}
}
Ausgabe
HashSet1: [2, 3, 5] HashSet2: [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.HashSet;
class Main {
public static void main(String[] args) {
HashSet<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
System.out.println("HashSet1: " + numbers);
HashSet<Integer> primeNumbers = new HashSet<>();
primeNumbers.add(2);
primeNumbers.add(3);
System.out.println("HashSet2: " + primeNumbers);
// Check if primeNumbers is a subset of numbers
boolean result = numbers.containsAll(primeNumbers);
System.out.println("Is HashSet2 is subset of HashSet1? " + result);
}
}
Ausgabe
HashSet1: [1, 2, 3, 4] HashSet2: [2, 3] Is HashSet2 is a subset of HashSet1? true
Andere HashSet-Methoden
| Methode | Beschreibung |
|---|---|
clone() | Erzeugt eine Kopie von HashSet |
contains() | Sucht nach HashSet für das angegebene Element und gibt ein boolesches Ergebnis | zurück
isEmpty() | Überprüft, ob der HashSet ist leer |
size() | Gibt die Größe von HashSet zurück |
clear() | Entfernt alle Elemente aus HashSet |
Um mehr über HashSet-Methoden zu erfahren, besuchen Sie Java HashSet (offizielle Java-Dokumentation).
Warum HashSet?
In Java HashSet wird häufig verwendet, wenn wir zufällig auf Elemente zugreifen müssen. Dies liegt daran, dass auf Elemente in einer Hash-Tabelle mithilfe von Hash-Codes zugegriffen wird.
Der Hashcode eines Elements ist eine eindeutige Identität, die dabei hilft, das Element in einer Hash-Tabelle zu identifizieren.
HashSet darf keine doppelten Elemente enthalten. Daher hat jedes Hash-Set-Element einen eindeutigen Hashcode.
Hinweis: HashSet wird nicht synchronisiert. Das heißt, wenn mehrere Threads gleichzeitig auf das Hash-Set zugreifen und einer der Threads das Hash-Set modifiziert. Dann muss es extern synchronisiert werden.
Java