Wie man prüft, ob ein Set in Java leer ist

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein Set in Java leer ist. Wir werden die Standardmethode isEmpty() untersuchen, eine einfache und effiziente Möglichkeit, festzustellen, ob ein Set Elemente enthält.

Sie werden auch lernen, wie Sie die Größe eines Sets mithilfe der Methode size() überprüfen und verstehen, wie Sie potenzielle NullPointerException behandeln können, wenn Sie mit Null-Sets umgehen. Am Ende dieses Labs können Sie die Leerheit von Java-Sets in verschiedenen Szenarien sicher prüfen.

Verwenden Sie isEmpty() für die Set-Prüfung

In diesem Schritt lernen wir, wie man prüft, ob ein Set in Java leer ist, indem man die Methode isEmpty() verwendet. Ein Set ist eine Sammlung, die keine doppelten Elemente enthalten kann. Die Methode isEmpty() ist eine einfache und effiziente Möglichkeit, festzustellen, ob eine Sammlung Elemente enthält.

Zunächst erstellen wir eine neue Java-Datei namens SetCheck.java im Verzeichnis ~/project. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann SetCheck.java eingeben.
Öffnen Sie die Datei SetCheck.java im Editor und fügen Sie den folgenden Code hinzu:
```
import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Create a new HashSet
        Set<String> fruits = new HashSet<>();

        // Check if the set is empty using isEmpty()
        boolean isEmptyBeforeAdd = fruits.isEmpty();
        System.out.println("Is the fruits set empty before adding elements? " + isEmptyBeforeAdd);

        // Add some elements to the set
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check if the set is empty after adding elements
        boolean isEmptyAfterAdd = fruits.isEmpty();
        System.out.println("Is the fruits set empty after adding elements? " + isEmptyAfterAdd);
    }
}
```
Lassen Sie uns die neuen Teile dieses Codes analysieren:
- import java.util.HashSet; und import java.util.Set;: Diese Zeilen importieren die notwendigen Klassen, um mit Set und HashSet zu arbeiten.
- Set<String> fruits = new HashSet<>();: Diese Zeile erstellt ein neues HashSet-Objekt namens fruits. Wir geben <String> an, um anzuzeigen, dass dieses Set String-Objekte speichern wird.
- boolean isEmptyBeforeAdd = fruits.isEmpty();: Diese Zeile ruft die Methode isEmpty() auf dem fruits-Set auf und speichert das Ergebnis (entweder true oder false) in einer booleschen Variablen namens isEmptyBeforeAdd.
- fruits.add("Apple");: Diese Zeile fügt die Zeichenkette "Apple" dem fruits-Set hinzu.
- boolean isEmptyAfterAdd = fruits.isEmpty();: Diese Zeile prüft erneut, ob das Set leer ist, nachdem Elemente hinzugefügt wurden.
Speichern Sie die Datei SetCheck.java (Strg+S oder Cmd+S).
Jetzt kompilieren wir das Java-Programm. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann den folgenden Befehl aus:
```
javac SetCheck.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java SetCheck
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Is the fruits set empty before adding elements? true
Is the fruits set empty after adding elements? false
```
Diese Ausgabe bestätigt, dass die Methode isEmpty() den Zustand des Sets vor und nach dem Hinzufügen von Elementen korrekt gemeldet hat.

Überprüfen Sie die Größe eines Sets mit size()

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob ein Set leer ist, indem man die Methode isEmpty() verwendet. Eine weitere häufige Operation besteht darin, herauszufinden, wie viele Elemente sich in einem Set befinden. Hierfür verwenden wir die Methode size(). Die Methode size() gibt die Anzahl der Elemente zurück, die sich derzeit im Set befinden.

Öffnen Sie die Datei SetCheck.java im Verzeichnis ~/project im WebIDE-Editor.

Modifizieren Sie die main-Methode, um Aufrufe der Methode size() einzubeziehen. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Create a new HashSet
        Set<String> fruits = new HashSet<>();

        // Check the size of the set before adding elements
        int sizeBeforeAdd = fruits.size();
        System.out.println("Size of the fruits set before adding elements: " + sizeBeforeAdd);

        // Add some elements to the set
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Check the size of the set after adding elements
        int sizeAfterAdd = fruits.size();
        System.out.println("Size of the fruits set after adding elements: " + sizeAfterAdd);

        // Add a duplicate element (Sets do not allow duplicates)
        fruits.add("Apple");

        // Check the size again
        int sizeAfterDuplicateAdd = fruits.size();
        System.out.println("Size of the fruits set after adding a duplicate: " + sizeAfterDuplicateAdd);
    }
}

Hier ist, was wir hinzugefügt haben:

int sizeBeforeAdd = fruits.size();: Diese Zeile ruft die Methode size() auf dem fruits-Set auf und speichert den zurückgegebenen ganzzahligen Wert (die Anzahl der Elemente) in einer Variablen namens sizeBeforeAdd.
int sizeAfterAdd = fruits.size();: Diese Zeile prüft die Größe nach dem Hinzufügen der ersten drei Elemente.
fruits.add("Apple");: Wir versuchen, "Apple" erneut hinzuzufügen. Da "Apple" bereits im Set enthalten ist, wird diese Operation den Inhalt des Sets nicht ändern.
int sizeAfterDuplicateAdd = fruits.size();: Diese Zeile prüft die Größe nach dem Versuch, ein Duplikat hinzuzufügen.

Speichern Sie die Datei SetCheck.java.
Kompilieren Sie das modifizierte Java-Programm im Terminal:
```
javac SetCheck.java
```
Wiederum zeigt die fehlende Ausgabe an, dass die Kompilierung erfolgreich war.
Führen Sie das Programm aus:
```
java SetCheck
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Size of the fruits set before adding elements: 0
Size of the fruits set after adding elements: 3
Size of the fruits set after adding a duplicate: 3
```
Diese Ausgabe zeigt, dass die Methode size() die Anzahl der Elemente korrekt meldet und dass das Hinzufügen eines Duplikat-Elements die Größe des Sets nicht erhöht.

Behandeln von Null-Sets

In den vorherigen Schritten haben wir mit einem korrekt initialisierten Set gearbeitet. In der Praxis der Programmierung können Sie jedoch Situationen antreffen, in denen eine Set-Variable null ist. Wenn Sie versuchen, Methoden wie isEmpty() oder size() auf ein null-Objekt aufzurufen, führt dies zu einer NullPointerException, einem häufigen Fehler in Java. Es ist wichtig, diese Fälle angemessen zu behandeln.

Öffnen Sie die Datei SetCheck.java im Verzeichnis ~/project im WebIDE-Editor.

Modifizieren Sie die main-Methode, um zu zeigen, wie man mit einem null-Set umgeht. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

import java.util.HashSet;
import java.util.Set;

public class SetCheck {

    public static void main(String[] args) {
        // Declare a Set variable but initialize it to null
        Set<String> colors = null;

        // Attempting to call isEmpty() or size() here would cause a NullPointerException
        // System.out.println("Is the colors set empty? " + colors.isEmpty()); // This would crash!

        // To safely check if a set is null or empty, we first check for null
        if (colors == null) {
            System.out.println("The colors set is null.");
        } else {
            // If it's not null, we can safely check if it's empty
            if (colors.isEmpty()) {
                System.out.println("The colors set is empty.");
            } else {
                System.out.println("The colors set is not empty and has " + colors.size() + " elements.");
            }
        }

        // Now, let's initialize the set and add elements
        colors = new HashSet<>();
        colors.add("Red");
        colors.add("Blue");

        // Check again after initialization and adding elements
        if (colors == null) {
            System.out.println("The colors set is null.");
        } else {
            if (colors.isEmpty()) {
                System.out.println("The colors set is empty.");
            } else {
                System.out.println("The colors set is not empty and has " + colors.size() + " elements.");
            }
        }
    }
}

In diesem aktualisierten Code:

Set<String> colors = null;: Wir deklarieren eine Set-Variable colors und setzen sie explizit auf null.
Wir haben die Zeile auskommentiert, die eine NullPointerException verursachen würde.
if (colors == null): Dies ist die entscheidende Prüfung. Bevor wir irgendeine Methode auf die colors-Variable aufrufen, prüfen wir zunächst, ob sie null ist.
Wenn colors nicht null ist, prüfen wir dann, ob es leer ist, indem wir colors.isEmpty() verwenden, oder wir ermitteln seine Größe mit colors.size().
Wir initialisieren dann colors mit einem neuen HashSet und fügen Elemente hinzu, um die unterschiedliche Ausgabe zu zeigen, wenn das Set nicht null und nicht leer ist.

Speichern Sie die Datei SetCheck.java.
Kompilieren Sie das Programm im Terminal:
```
javac SetCheck.java
```
Führen Sie das Programm aus:
```
java SetCheck
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
The colors set is null.
The colors set is not empty and has 2 elements.
```
Dies zeigt, wie man potenzielle null-Werte für eine Set-Variable sicher behandelt, bevor man versucht, auf ihre Methoden zuzugreifen. Prüfen Sie immer zuerst auf null, wenn Sie mit Objektreferenzen arbeiten, die möglicherweise nicht initialisiert sind.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Set in Java leer ist. Wir haben begonnen, die Methode isEmpty() zu verwenden, die der Standard- und effizienteste Weg ist, um diese Prüfung durchzuführen. Wir haben ein HashSet erstellt, seinen Leerstatus vor und nach dem Hinzufügen von Elementen geprüft und die boolesche Ausgabe von isEmpty() beobachtet. Dies hat die grundlegende Verwendung von isEmpty() zur Bestimmung, ob ein Set Elemente enthält, demonstriert.