In diesem Lab werden Sie lernen, wie Sie in Java überprüfen können, ob eine Menge alle Elemente einer anderen Menge enthält. Wir werden die Methode containsAll() untersuchen, die eine bequeme Möglichkeit ist, diese Überprüfung auf Teilmengen durchzuführen.
Anhand von praktischen Beispielen werden Sie lernen, wie Sie containsAll() mit verschiedenen Mengentypen verwenden und wie Sie Randfälle wie leere und Null-Mengen behandeln.
In diesem Schritt werden wir untersuchen, wie Sie mithilfe der Methode containsAll() in Java überprüfen können, ob eine Menge eine Teilmenge einer anderen Menge ist. Dies ist eine häufige Operation bei der Arbeit mit Sammlungen, und containsAll() bietet eine bequeme Möglichkeit, diese Überprüfung durchzuführen.
Zunächst erstellen wir eine neue Java-Datei mit dem Namen SubsetCheck.java in Ihrem ~/project-Verzeichnis. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann SubsetCheck.java eingeben.
Öffnen Sie nun die Datei SubsetCheck.java im Editor und fügen Sie den folgenden Code hinzu:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
// Create the main set
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
mainSet.add(4);
mainSet.add(5);
// Create a potential subset
Set<Integer> subset = new HashSet<>();
subset.add(2);
subset.add(4);
// Check if 'subset' is a subset of 'mainSet'
boolean isSubset = mainSet.containsAll(subset);
// Print the result
System.out.println("Main Set: " + mainSet);
System.out.println("Subset: " + subset);
System.out.println("Is 'subset' a subset of 'mainSet'? " + isSubset);
}
}Lassen Sie uns den Code analysieren:
import java.util.HashSet; und import java.util.Set;: Diese Zeilen importieren die erforderlichen Klassen für die Arbeit mit Mengen.Set<Integer> mainSet = new HashSet<>();: Dies erstellt ein HashSet namens mainSet, das Ganzzahlwerte speichert.mainSet.add(...): Diese Zeilen fügen Elemente zur mainSet hinzu.Set<Integer> subset = new HashSet<>();: Dies erstellt ein weiteres HashSet namens subset.subset.add(...): Diese Zeilen fügen Elemente zur subset hinzu.boolean isSubset = mainSet.containsAll(subset);: Dies ist der Kern dieses Schritts. Die Methode containsAll() der mainSet wird mit subset als Argument aufgerufen. Sie gibt true zurück, wenn mainSet alle Elemente von subset enthält, und false sonst.System.out.println(...): Diese Zeilen geben die Mengen und das Ergebnis der Überprüfung auf Teilmengen in die Konsole aus.Speichern Sie die Datei SubsetCheck.java (Strg+S oder Cmd+S).
Öffnen Sie nun das Terminal unten im WebIDE. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden. Wenn nicht, verwenden Sie den Befehl cd ~/project.
Kompilieren Sie den Java-Code mit dem Befehl javac:
javac SubsetCheck.javaWenn keine Fehler auftreten, sollten Sie keine Ausgabe sehen. Dies bedeutet, dass die Kompilierung erfolgreich war und eine SubsetCheck.class-Datei erstellt wurde.
Führen Sie schließlich das kompilierte Java-Programm mit dem Befehl java aus:
java SubsetCheckSie sollten eine Ausgabe ähnlich der folgenden sehen:
Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? trueDiese Ausgabe bestätigt, dass die Methode containsAll() korrekt erkannt hat, dass subset tatsächlich eine Teilmenge von mainSet ist.
Im vorherigen Schritt haben wir HashSet verwendet, um die Methode containsAll() zu demonstrieren. Java bietet verschiedene Implementierungen des Set-Interfaces, wie HashSet, LinkedHashSet und TreeSet. Obwohl sie unterschiedliche interne Strukturen und Eigenschaften haben (z. B. die Reihenfolge), funktioniert die Methode containsAll() konsistent für alle diese Implementierungen.
In diesem Schritt werden wir die Datei SubsetCheck.java ändern, um containsAll() mit verschiedenen Mengentypen zu testen.
Öffnen Sie die Datei SubsetCheck.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden:
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SubsetCheck {
public static void main(String[] args) {
// Create a main set using HashSet
Set<Integer> hashMainSet = new HashSet<>();
hashMainSet.add(10);
hashMainSet.add(20);
hashMainSet.add(30);
hashMainSet.add(40);
// Create a subset using LinkedHashSet
Set<Integer> linkedSubset = new LinkedHashSet<>();
linkedSubset.add(30);
linkedSubset.add(10);
// Create another subset using TreeSet
Set<Integer> treeSubset = new TreeSet<>();
treeSubset.add(40);
treeSubset.add(20);
// Check subset relationship using containsAll()
boolean isLinkedSubset = hashMainSet.containsAll(linkedSubset);
boolean isTreeSubset = hashMainSet.containsAll(treeSubset);
// Create a subset that is NOT a subset
Set<Integer> notSubset = new HashSet<>();
notSubset.add(20);
notSubset.add(50); // 50 is not in hashMainSet
boolean isNotSubset = hashMainSet.containsAll(notSubset);
// Print the results
System.out.println("Hash Main Set: " + hashMainSet);
System.out.println("Linked Subset: " + linkedSubset);
System.out.println("Is Linked Subset a subset of Hash Main Set? " + isLinkedSubset);
System.out.println("Tree Subset: " + treeSubset);
System.out.println("Is Tree Subset a subset of Hash Main Set? " + isTreeSubset);
System.out.println("Not Subset: " + notSubset);
System.out.println("Is Not Subset a subset of Hash Main Set? " + isNotSubset);
}
}In diesem aktualisierten Code:
LinkedHashSet und TreeSet importiert.hashMainSet mithilfe von HashSet erstellt.linkedSubset mithilfe von LinkedHashSet und treeSubset mithilfe von TreeSet erstellt. Beachten Sie, dass die Reihenfolge der Elemente, die zu linkedSubset hinzugefügt werden, von der Reihenfolge in hashMainSet unterschiedlich ist, aber containsAll() funktioniert dennoch korrekt. TreeSet sortiert die Elemente automatisch.notSubset hinzugefügt, um einen Fall zu demonstrieren, in dem containsAll() false zurückgibt.Speichern Sie die Datei SubsetCheck.java.
Jetzt kompilieren Sie den geänderten Code im Terminal:
javac SubsetCheck.javaWenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:
java SubsetCheckSie sollten eine Ausgabe ähnlich der folgenden sehen:
Hash Main Set: [40, 10, 20, 30]
Linked Subset: [30, 10]
Is Linked Subset a subset of Hash Main Set? true
Tree Subset: [20, 40]
Is Tree Subset a subset of Hash Main Set? true
Not Subset: [50, 20]
Is Not Subset a subset of Hash Main Set? falseDies zeigt, dass containsAll() korrekt funktioniert, unabhängig von der spezifischen Set-Implementierung, die für die Teilmenge verwendet wird, solange die Hauptmenge alle Elemente der Teilmenge enthält.
In diesem letzten Schritt werden wir untersuchen, wie die Methode containsAll() bei der Arbeit mit leeren Mengen und Null-Werten verhält. Das Verständnis dieser Randfälle ist wichtig für die Entwicklung robuster Code.
Öffnen Sie die Datei SubsetCheck.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden:
import java.util.HashSet;
import java.util.Set;
public class SubsetCheck {
public static void main(String[] args) {
Set<Integer> mainSet = new HashSet<>();
mainSet.add(1);
mainSet.add(2);
mainSet.add(3);
// Case 1: Checking with an empty set
Set<Integer> emptySet = new HashSet<>();
boolean isEmptySubset = mainSet.containsAll(emptySet);
System.out.println("Main Set: " + mainSet);
System.out.println("Empty Set: " + emptySet);
System.out.println("Is Empty Set a subset of Main Set? " + isEmptySubset);
System.out.println("---"); // Separator
// Case 2: Checking if an empty set contains all elements of a non-empty set
Set<Integer> anotherEmptySet = new HashSet<>();
Set<Integer> nonEmptySet = new HashSet<>();
nonEmptySet.add(1);
boolean isEmptyContainingNonEmpty = anotherEmptySet.containsAll(nonEmptySet);
System.out.println("Another Empty Set: " + anotherEmptySet);
System.out.println("Non-Empty Set: " + nonEmptySet);
System.out.println("Is Another Empty Set a subset of Non-Empty Set? " + isEmptyContainingNonEmpty);
System.out.println("---"); // Separator
// Case 3: Checking with a null set
Set<Integer> nullSet = null;
try {
boolean isNullSubset = mainSet.containsAll(nullSet);
System.out.println("Is Null Set a subset of Main Set? " + isNullSubset);
} catch (NullPointerException e) {
System.out.println("Checking with a null set resulted in a: " + e.getClass().getName());
}
}
}Schauen wir uns die neuen Teile an:
emptySet und überprüfen, ob mainSet alle ihre Elemente enthält. Eine leere Menge wird als Teilmenge jeder anderen Menge angesehen, einschließlich einer anderen leeren Menge.anotherEmptySet alle Elemente von nonEmptySet enthält. Dies sollte false sein, da die leere Menge das Element 1 nicht enthält.Set-Variable auf null. Der Versuch, containsAll() mit einem null-Argument aufzurufen, führt zu einer NullPointerException. Wir verwenden einen try-catch-Block, um diese erwartete Ausnahme gracefully zu behandeln und eine Nachricht auszugeben.Speichern Sie die Datei SubsetCheck.java.
Kompilieren Sie den Code im Terminal:
javac SubsetCheck.javaFühren Sie das kompilierte Programm aus:
java SubsetCheckSie sollten eine Ausgabe ähnlich der folgenden sehen:
Main Set: [1, 2, 3]
Empty Set: []
Is Empty Set a subset of Main Set? true
---
Another Empty Set: []
Non-Empty Set: [1]
Is Another Empty Set a subset of Non-Empty Set? false
---
Checking with a null set resulted in a: java.lang.NullPointerExceptionDiese Ausgabe bestätigt das Verhalten von containsAll() bei leeren und Null-Mengen:
true).false).null an containsAll() führt zu einer NullPointerException.Das Verständnis dieser Fälle hilft Ihnen, potenzielle Fehler bei der Arbeit mit Mengen in Java zu vermeiden.
In diesem Lab haben wir gelernt, wie man in Java überprüft, ob eine Menge alle Elemente einer anderen Menge enthält, indem man die Methode containsAll() verwendet. Wir haben begonnen, indem wir ein einfaches Beispiel mit HashSet erstellt haben, um die Kernfunktionalität von containsAll() zu demonstrieren. Diese Methode bietet eine einfache Möglichkeit, festzustellen, ob eine potenzielle Teilmenge tatsächlich in einer größeren Menge enthalten ist.
Anschließend haben wir untersucht, wie man diese Funktionalität mit verschiedenen Mengentypen testen kann und verstanden, dass containsAll() konsistent für verschiedene Set-Implementierungen funktioniert. Schließlich haben wir die wichtigen Überlegungen beim Umgang mit leeren und Null-Mengen bei der Überprüfung von Teilmengen angesprochen, um einen robusten und fehlerfreien Code zu gewährleisten.
