Wie man prüft, ob ein Boolean-Objekt in Java null ist

Einführung

In diesem Lab erfahren Sie, wie Sie sicher prüfen können, ob ein Boolean-Wrapper-Objekt in Java null ist. Im Gegensatz zum primitiven boolean-Typ kann die Boolean-Klasse einen null-Wert enthalten, was zu einer NullPointerException führen kann, wenn es nicht richtig behandelt wird.

Wir werden verschiedene Techniken zur Behandlung von null-Boolean-Objekten untersuchen, einschließlich direkter Null-Prüfungen, Kombination von Null- und Wahr/Falsch-Prüfungen sowie die Verwendung der Optional-Klasse für eine robuster Null-Behandlung. Am Ende dieses Labs werden Sie in der Lage sein, häufige Fallstricke beim Arbeiten mit Boolean-Wrapper-Objekten in Java zu vermeiden.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java/BasicSyntaxGroup -.-> java/booleans("Booleans") java/BasicSyntaxGroup -.-> java/variables("Variables") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/SystemandDataProcessingGroup -.-> java/object_methods("Object Methods") subgraph Lab Skills java/booleans -.-> lab-559932{{"Wie man prüft, ob ein Boolean-Objekt in Java null ist"}} java/variables -.-> lab-559932{{"Wie man prüft, ob ein Boolean-Objekt in Java null ist"}} java/if_else -.-> lab-559932{{"Wie man prüft, ob ein Boolean-Objekt in Java null ist"}} java/object_methods -.-> lab-559932{{"Wie man prüft, ob ein Boolean-Objekt in Java null ist"}} end

Prüfen auf Null bei Boolean-Wrapper-Objekten

In diesem Schritt werden wir untersuchen, wie man Boolean-Wrapper-Objekte in Java behandelt, wobei wir uns speziell auf die Prüfung darauf konzentrieren, ob ein Boolean-Objekt null ist. Im Gegensatz zum primitiven boolean-Typ, der nur true oder false sein kann, kann die Boolean-Wrapper-Klasse auch einen null-Wert enthalten. Dies ist eine häufige Ursache für NullPointerException, wenn es nicht sorgfältig behandelt wird.

Lassen Sie uns ein einfaches Java-Programm erstellen, um dies zu demonstrieren.

Öffnen Sie das Verzeichnis ~/project im Dateiexplorer auf der linken Seite der WebIDE.
Klicken Sie mit der rechten Maustaste in den leeren Bereich innerhalb des ~/project-Verzeichnisses und wählen Sie "Neue Datei".
Benennen Sie die neue Datei BooleanCheck.java und drücken Sie die Eingabetaste.
Öffnen Sie die Datei BooleanCheck.java im Code-Editor.

Kopieren und fügen Sie den folgenden Java-Code in den Editor ein:

public class BooleanCheck {

    public static void main(String[] args) {
        Boolean myBoolean = null;

        // Versuch, ein null-Boolean direkt in einer Bedingung zu verwenden
        // führt zu einer NullPointerException
        // if (myBoolean) {
        //     System.out.println("This will not be printed if myBoolean is null.");
        // }

        // Korrekte Methode, um zu prüfen, ob ein Boolean-Wrapper null ist
        if (myBoolean == null) {
            System.out.println("myBoolean is null.");
        } else {
            System.out.println("myBoolean is not null.");
        }

        // Eine andere Möglichkeit, den booleschen Wert sicher zu prüfen
        if (Boolean.TRUE.equals(myBoolean)) {
             System.out.println("myBoolean is true.");
        } else if (Boolean.FALSE.equals(myBoolean)) {
             System.out.println("myBoolean is false.");
        } else {
             System.out.println("myBoolean is null (checked using equals).");
        }
    }
}

Speichern Sie die Datei, indem Sie Strg + S drücken (oder Cmd + S auf einem Mac).
Jetzt lassen Sie uns das Java-Programm kompilieren. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, geben Sie cd ~/project ein und drücken Sie die Eingabetaste.
Kompilieren Sie den Code mit dem Befehl javac:
```
javac BooleanCheck.java
```
Wenn keine Fehler auftreten, wird der Befehl ohne Ausgabe abgeschlossen. Dies bedeutet, dass eine BooleanCheck.class-Datei im Verzeichnis ~/project erstellt wurde.
Führen Sie das kompilierte Java-Programm mit dem Befehl java aus:
```
java BooleanCheck
```

Sie sollten die folgende Ausgabe im Terminal sehen:

myBoolean is null.
myBoolean is null (checked using equals).

Diese Ausgabe bestätigt, dass unser Code das Boolean-Objekt korrekt als null identifiziert hat, indem es die Prüfung == null und das Muster Boolean.TRUE.equals() / Boolean.FALSE.equals() verwendet hat. Der auskommentierte Code zeigt, was passieren würde, wenn Sie versuchen würden, ein null-Boolean direkt in einer if-Bedingung zu verwenden, was zu einer NullPointerException führen würde.

Das Verständnis, wie man null-Boolean-Objekte sicher behandelt, ist entscheidend, um häufige Fehler in der Java-Programmierung zu vermeiden.

Kombinieren von Null- und Wahr/Falsch-Prüfungen

Im vorherigen Schritt haben wir gesehen, wie man prüft, ob ein Boolean-Objekt null ist. Oft müssen Sie prüfen, ob ein Boolean-Wert true, false oder null ist. Das effiziente und sichere Kombinieren dieser Prüfungen ist wichtig.

Lassen Sie uns unser BooleanCheck.java-Programm ändern, um zu zeigen, wie man alle drei Möglichkeiten behandelt.

Öffnen Sie die Datei BooleanCheck.java im Code-Editor, wenn sie noch nicht geöffnet ist. Sie sollte sich im Verzeichnis ~/project befinden.

Ersetzen Sie den vorhandenen Code in BooleanCheck.java durch den folgenden Code. Diese Version enthält Beispiele für null, true und false als Boolean-Werte.

public class BooleanCheck {

    public static void main(String[] args) {
        Boolean booleanValue1 = null;
        Boolean booleanValue2 = true;
        Boolean booleanValue3 = false;

        System.out.println("Checking booleanValue1 (null):");
        checkBoolean(booleanValue1);

        System.out.println("\nChecking booleanValue2 (true):");
        checkBoolean(booleanValue2);

        System.out.println("\nChecking booleanValue3 (false):");
        checkBoolean(booleanValue3);
    }

    // Eine Hilfsmethode, um die Prüfungen zu demonstrieren
    public static void checkBoolean(Boolean value) {
        if (value == null) {
            System.out.println("Value is null.");
        } else if (value) { // Dies ist sicher, da wir bereits auf null geprüft haben
            System.out.println("Value is true.");
        } else { // Wenn nicht null und nicht true, muss es false sein
            System.out.println("Value is false.");
        }

        // Ein weiteres gängiges Muster unter Verwendung von equals für die Sicherheit
        System.out.print("Using equals: ");
        if (Boolean.TRUE.equals(value)) {
             System.out.println("Value is true.");
        } else if (Boolean.FALSE.equals(value)) {
             System.out.println("Value is false.");
        } else {
             System.out.println("Value is null.");
        }
    }
}

In diesem aktualisierten Code:

Wir definieren eine Hilfsmethode checkBoolean, die ein Boolean-Objekt als Eingabe nimmt.
Innerhalb von checkBoolean prüfen wir zunächst, ob der value null ist, indem wir value == null verwenden.
Wenn er nicht null ist, prüfen wir dann sicher, ob der boolesche Wert true ist, indem wir value verwenden. Dies funktioniert, weil Java das Boolean-Wrapper-Objekt nur dann in einen primitiven boolean-Wert umwandelt, wenn das Wrapper-Objekt nicht null ist.
Wenn er nicht null und nicht true ist, muss er false sein, was im else-Block behandelt wird.
Wir verwenden auch erneut das Muster Boolean.TRUE.equals(value) und Boolean.FALSE.equals(value), was eine weitere sichere Möglichkeit ist, den Wert zu prüfen, insbesondere wenn Sie potenzielle NullPointerException vermeiden möchten, wenn das Objekt, auf dem equals aufgerufen wird, null ist.

Speichern Sie die Datei (Strg + S oder Cmd + S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac BooleanCheck.java
```
Führen Sie das kompilierte Programm aus:
```
java BooleanCheck
```

Sie sollten die folgende Ausgabe sehen, die zeigt, wie der Code jedes Fall behandelt:

Checking booleanValue1 (null):
Value is null.
Using equals: Value is null.

Checking booleanValue2 (true):
Value is true.
Using equals: Value is true.

Checking booleanValue3 (false):
Value is false.
Using equals: Value is false.

Dieser Schritt zeigt Ihnen robuste Methoden, um den Zustand eines Boolean-Wrapper-Objekts zu prüfen, wobei null, true und false-Werte berücksichtigt werden. Dies ist eine grundlegende Fähigkeit für das Schreiben von sicheren und zuverlässigen Java-Code.

Umgang mit der Optional-Klasse

In modernem Java (Java 8 und neuer) wird die Optional-Klasse oft verwendet, um einen Wert darzustellen, der vorhanden oder auch nicht vorhanden sein kann. Dies kann dazu beitragen, die Anzahl der NullPointerExceptions in Ihrem Code zu reduzieren, indem es klar wird, wann ein Wert fehlen kann. Obwohl Optional<Boolean> nicht immer der häufigste Anwendungsfall ist, ist es eine gute Möglichkeit, zu verstehen, wie Optional auf Wrapper-Typen wie Boolean angewendet werden kann.

In diesem Schritt werden wir unser Programm ändern, um Optional<Boolean> zu verwenden, um die Möglichkeit eines fehlenden booleschen Werts zu behandeln.

Öffnen Sie die Datei BooleanCheck.java im Code-Editor. Sie sollte sich im Verzeichnis ~/project befinden.

Ersetzen Sie den vorhandenen Code durch den folgenden Code, der Optional<Boolean> verwendet:

import java.util.Optional;

public class BooleanCheck {

    public static void main(String[] args) {
        Optional<Boolean> optionalBoolean1 = Optional.empty(); // Represents no value
        Optional<Boolean> optionalBoolean2 = Optional.of(true); // Represents the value true
        Optional<Boolean> optionalBoolean3 = Optional.of(false); // Represents the value false

        System.out.println("Checking optionalBoolean1 (empty):");
        checkOptionalBoolean(optionalBoolean1);

        System.out.println("\nChecking optionalBoolean2 (true):");
        checkOptionalBoolean(optionalBoolean2);

        System.out.println("\nChecking optionalBoolean3 (false):");
        checkOptionalBoolean(optionalBoolean3);
    }

    // A helper method to demonstrate checking Optional<Boolean>
    public static void checkOptionalBoolean(Optional<Boolean> optionalValue) {
        if (optionalValue.isPresent()) {
            // Get the boolean value if present
            Boolean value = optionalValue.get();
            if (value) {
                System.out.println("Value is present and true.");
            } else {
                System.out.println("Value is present and false.");
            }
        } else {
            System.out.println("Value is not present (empty Optional).");
        }

        // Another way using orElse
        System.out.print("Using orElse(false): ");
        boolean result = optionalValue.orElse(false);
        System.out.println("Result: " + result);

        // Using ifPresent
        System.out.print("Using ifPresent: ");
        optionalValue.ifPresent(val -> System.out.println("Value is present: " + val));
        if (!optionalValue.isPresent()) {
             System.out.println("Value is not present.");
        }
    }
}

In dieser Version:

Wir importieren die java.util.Optional-Klasse.
Wir erstellen Optional<Boolean>-Objekte mit Optional.empty() für einen fehlenden Wert und Optional.of() für einen vorhandenen Wert.
Die Methode checkOptionalBoolean nimmt jetzt ein Optional<Boolean> entgegen.
Wir verwenden optionalValue.isPresent(), um zu prüfen, ob ein Wert vorhanden ist.
Wenn ein Wert vorhanden ist, holen wir ihn mit optionalValue.get() ab. Hinweis: Rufen Sie get() nur auf, nachdem Sie isPresent() geprüft haben, sonst erhalten Sie eine NoSuchElementException.
Wir demonstrieren auch orElse(false), das einen Standardwert (false in diesem Fall) liefert, wenn das Optional leer ist.
ifPresent() ermöglicht es Ihnen, eine Aktion nur auszuführen, wenn ein Wert vorhanden ist.

Speichern Sie die Datei (Strg + S oder Cmd + S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac BooleanCheck.java
```
Führen Sie das kompilierte Programm aus:
```
java BooleanCheck
```

Sie sollten die folgende Ausgabe sehen:

Checking optionalBoolean1 (empty):
Value is not present (empty Optional).
Using orElse(false): Result: false
Using ifPresent: Value is not present.

Checking optionalBoolean2 (true):
Value is present and true.
Using orElse(false): Result: true
Using ifPresent: Value is present: true

Checking optionalBoolean3 (false):
Value is present and false.
Using orElse(false): Result: false
Using ifPresent: Value is present: false

Diese Ausgabe zeigt, wie Optional<Boolean> verwendet werden kann, um explizit das Vorhandensein oder Fehlen eines booleschen Werts zu behandeln. Dies bietet eine robusteren Weg, mit potenziell fehlenden Daten umzugehen, als nur einen nullable Boolean zu verwenden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Boolean-Wrapper-Objekt in Java null ist. Wir haben den Unterschied zwischen dem primitiven boolean-Typ und der Boolean-Wrapper-Klasse untersucht und dabei auf das Potenzial für NullPointerException hingewiesen, wenn man mit null-Boolean-Objekten umgeht. Wir haben gezeigt, wie man korrekt auf null prüft, indem man den Gleichheitsoperator (== null) verwendet, und auch, wie man den booleschen Wert sicher prüft, indem man die equals()-Methode von Boolean.TRUE und Boolean.FALSE nutzt. Diese Techniken sind von entscheidender Bedeutung, um Laufzeitfehler beim Umgang mit nullable Boolean-Objekten zu vermeiden.