So überprüfen Sie, ob eine Menge alle Elemente einer anderen Menge in Java enthält

Einführung

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.

Skills Graph

Verwendung von containsAll() für die Überprüfung auf Teilmengen

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.java

Wenn 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 SubsetCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Main Set: [1, 2, 3, 4, 5]
Subset: [2, 4]
Is 'subset' a subset of 'mainSet'? true

Diese Ausgabe bestätigt, dass die Methode containsAll() korrekt erkannt hat, dass subset tatsächlich eine Teilmenge von mainSet ist.

Test mit verschiedenen Mengentypen

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:

• Wir haben LinkedHashSet und TreeSet importiert.
• Wir haben ein hashMainSet mithilfe von HashSet erstellt.
• Wir haben 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.
• Wir haben auch ein 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.java

Wenn die Kompilierung erfolgreich ist, führen Sie das Programm aus:

java SubsetCheck

Sie 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? false

Dies 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.

Umgang mit leeren und Null-Mengen

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:

• Fall 1: Überprüfung mit einer leeren Menge: Wir erstellen eine 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.
• Fall 2: Überprüfung, ob eine leere Menge alle Elemente einer nicht-leeren Menge enthält: Wir überprüfen, ob anotherEmptySet alle Elemente von nonEmptySet enthält. Dies sollte false sein, da die leere Menge das Element 1 nicht enthält.
• Fall 3: Überprüfung mit einer Null-Menge: Wir setzen eine 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.java

Führen Sie das kompilierte Programm aus:

java SubsetCheck

Sie 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.NullPointerException

Diese Ausgabe bestätigt das Verhalten von containsAll() bei leeren und Null-Mengen:

• Eine leere Menge ist immer eine Teilmenge einer anderen Menge (true).
• Eine nicht-leere Menge ist niemals eine Teilmenge einer leeren Menge (false).
• Das Übergeben von 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.

Zusammenfassung

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.