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

Einführung

In diesem Lab lernen Sie, wie Sie Integer-Wrapper-Objekte in Java sicher handhaben können, wobei der Schwerpunkt insbesondere darauf liegt, zu prüfen, ob sie null sind. Im Gegensatz zum primitiven int ist Integer ein Objekt, das eine null-Referenz enthalten kann. Wenn Sie nicht auf null prüfen, kann dies zu häufigen NullPointerException-Fehlern führen.

Anhand praktischer Beispiele werden Sie die grundlegende Prüfung auf == null untersuchen, Null-Prüfungen mit Wertvergleichen kombinieren und schließlich lernen, wie Sie die Optional-Klasse nutzen können, um in Ihrem Java-Code eine robusteres und ausdrucksstärkeres Null-Handling zu implementieren.

Prüfen, ob ein Integer-Wrapper null ist

In diesem Schritt werden wir untersuchen, wie man Integer-Wrapper-Objekte in Java handhabt, wobei der Schwerpunkt insbesondere darauf liegt, zu prüfen, ob sie null sind. Im Gegensatz zu primitiven Datentypen wie int ist Integer eine Klasse. Das bedeutet, dass eine Integer-Variable eine Referenz auf ein Objekt enthalten kann oder null sein kann, wenn sie auf kein Objekt verweist. Das Handling von null-Werten ist in Java von entscheidender Bedeutung, um NullPointerException-Fehler zu vermeiden. Diese Fehler sind sehr häufig und können Ihr Programm abstürzen lassen.

Erstellen wir ein einfaches Java-Programm, um das Prüfen auf null mit einem Integer zu demonstrieren.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Wenn Sie das vorherige Lab abgeschlossen haben, sollte diese Datei bereits im Verzeichnis ~/project existieren.

Ersetzen Sie den vorhandenen Code in HelloJava.java durch folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        Integer myInteger = null; // Declaring an Integer and setting it to null

        // Check if myInteger is null
        if (myInteger == null) {
            System.out.println("myInteger is null.");
        } else {
            System.out.println("myInteger is not null. Its value is: " + myInteger);
        }

        // Let's try with a non-null Integer
        Integer anotherInteger = 10; // Declaring and initializing with a value

        // Check if anotherInteger is null
        if (anotherInteger == null) {
            System.out.println("anotherInteger is null.");
        } else {
            System.out.println("anotherInteger is not null. Its value is: " + anotherInteger);
        }
    }
}

In diesem Code:

Wir deklarieren eine Integer-Variable myInteger und setzen sie explizit auf null.
Wir verwenden eine if-Anweisung, um zu prüfen, ob myInteger gleich null ist, indem wir den ==-Operator verwenden. Dies ist die Standardmethode, um zu prüfen, ob eine Objektreferenz in Java null ist.
Wir deklarieren dann eine weitere Integer-Variable anotherInteger und weisen ihr den Wert 10 zu. Java konvertiert automatisch den primitiven int-Wert 10 in ein Integer-Objekt (dies wird als Autoboxing bezeichnet).
Wir führen die gleiche null-Prüfung für anotherInteger durch.

Speichern Sie die Datei HelloJava.java (Strg+S oder Cmd+S).
Kompilieren Sie jetzt das Programm mit dem Befehl javac im Terminal. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird die Kompilierung ohne Meldung abgeschlossen, und es wird eine Datei HelloJava.class im Verzeichnis ~/project erstellt.
Führen Sie das kompilierte Programm mit dem Befehl java aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
myInteger is null.
anotherInteger is not null. Its value is: 10
```
Diese Ausgabe bestätigt, dass unsere null-Prüfung sowohl für das null-Integer als auch für das nicht-null-Integer korrekt funktioniert hat. Das Verständnis, wie man auf null prüft, ist eine grundlegende Fähigkeit in der Java-Programmierung, insbesondere wenn es um Wrapper-Klassen und Objekte geht, denen möglicherweise nicht immer ein Wert zugewiesen ist.

Kombinieren von Null- und Wertprüfungen

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob ein Integer-Objekt null ist. Oft müssen Sie prüfen, ob ein Integer nicht null ist UND ob sein Wert eine bestimmte Bedingung erfüllt. Das Kombinieren dieser Prüfungen ist wichtig, da der Versuch, den Wert eines null-Integer-Objekts zuzugreifen, zu einer NullPointerException führt.

Ändern wir unser Programm, um das Kombinieren einer null-Prüfung mit einer Wertprüfung zu demonstrieren.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        Integer score = null; // Example 1: score is null

        // Check if score is not null AND its value is greater than 50
        if (score != null && score > 50) {
            System.out.println("Score is not null and is greater than 50.");
        } else {
            System.out.println("Score is null or not greater than 50.");
        }

        Integer anotherScore = 75; // Example 2: score is 75

        // Check if anotherScore is not null AND its value is greater than 50
        if (anotherScore != null && anotherScore > 50) {
            System.out.println("anotherScore is not null and is greater than 50.");
        } else {
            System.out.println("anotherScore is null or not greater than 50.");
        }

        Integer yetAnotherScore = 40; // Example 3: score is 40

        // Check if yetAnotherScore is not null AND its value is greater than 50
        if (yetAnotherScore != null && yetAnotherScore > 50) {
            System.out.println("yetAnotherScore is not null and is greater than 50.");
        } else {
            System.out.println("yetAnotherScore is null or not greater than 50.");
        }
    }
}

In diesem aktualisierten Code:

Wir verwenden den logischen UND-Operator (&&), um zwei Bedingungen zu kombinieren: score != null und score > 50.
Die Prüfung score != null wird zuerst durchgeführt. In Java verwendet der &&-Operator die Kurzschlussauswertung. Das bedeutet, wenn die erste Bedingung (score != null) falsch ist, wird die zweite Bedingung (score > 50) nicht ausgewertet. Dies verhindert eine NullPointerException, wenn score null ist, da der Code score > 50 nicht ausgeführt wird.
Wir testen diese Logik mit drei verschiedenen Integer-Variablen: einer, die null ist, einer, die nicht null ist und größer als 50 ist, und einer, die nicht null ist, aber nicht größer als 50 ist.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Score is null or not greater than 50.
anotherScore is not null and is greater than 50.
yetAnotherScore is null or not greater than 50.
```
Diese Ausgabe zeigt, wie die kombinierte Prüfung funktioniert. Im ersten Fall wird korrekt erkannt, dass score null ist. Im zweiten Fall wird erkannt, dass anotherScore nicht null ist und größer als 50 ist. Im dritten Fall wird erkannt, dass yetAnotherScore nicht größer als 50 ist, obwohl es nicht null ist. Dieses Muster der Prüfung auf null vor dem Zugriff auf die Eigenschaften oder den Wert eines Objekts ist eine grundlegende Sicherheitsmaßnahme in Java.

Verwenden von Optional für sicheres Handling

Während das Prüfen auf null mit == null und das Kombinieren von Prüfungen mit && effektiv ist, hat Java 8 die Optional-Klasse als idiomatischere Methode eingeführt, um Werte zu verarbeiten, die fehlen können (d. h. null sein können). Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder auch nicht. Die Verwendung von Optional kann dazu beitragen, dass Ihr Code lesbarer wird und weniger anfällig für NullPointerException-Fehler ist.

In diesem Schritt werden wir unser Programm umgestalten, um Optional<Integer> zur Verarbeitung möglicherweise fehlender ganzzahliger Werte zu verwenden.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Ersetzen Sie den vorhandenen Code durch folgenden Code:

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        // Example 1: Optional containing a null value (empty Optional)
        Optional<Integer> optionalScoreNull = Optional.empty();

        // Check if the Optional contains a value and if it's greater than 50
        if (optionalScoreNull.isPresent() && optionalScoreNull.get() > 50) {
             System.out.println("optionalScoreNull is present and greater than 50.");
        } else {
             System.out.println("optionalScoreNull is empty or not greater than 50.");
        }

        // Example 2: Optional containing a non-null value (75)
        Optional<Integer> optionalScorePresent = Optional.of(75);

        // Check if the Optional contains a value and if it's greater than 50
        if (optionalScorePresent.isPresent() && optionalScorePresent.get() > 50) {
             System.out.println("optionalScorePresent is present and greater than 50.");
        } else {
             System.out.println("optionalScorePresent is empty or not greater than 50.");
        }

        // Example 3: Optional containing a non-null value (40)
        Optional<Integer> optionalScoreNotGreater = Optional.of(40);

        // Check if the Optional contains a value and if it's greater than 50
        if (optionalScoreNotGreater.isPresent() && optionalScoreNotGreater.get() > 50) {
             System.out.println("optionalScoreNotGreater is present and greater than 50.");
        } else {
             System.out.println("optionalScoreNotGreater is empty or not greater than 50.");
        }

        // A more functional way using Optional methods
        System.out.println("\nUsing Optional methods:");

        optionalScoreNull.ifPresent(value -> System.out.println("Value from optionalScoreNull: " + value));
        optionalScorePresent.ifPresent(value -> System.out.println("Value from optionalScorePresent: " + value));
        optionalScoreNotGreater.ifPresent(value -> System.out.println("Value from optionalScoreNotGreater: " + value));

        // Using orElse to provide a default value if Optional is empty
        Integer scoreOrDefault = optionalScoreNull.orElse(0);
        System.out.println("Value from optionalScoreNull with default: " + scoreOrDefault);

        // Using filter for conditional checks
        optionalScorePresent.filter(value -> value > 50)
                            .ifPresent(value -> System.out.println("Filtered optionalScorePresent value: " + value));

         optionalScoreNotGreater.filter(value -> value > 50)
                            .ifPresent(value -> System.out.println("Filtered optionalScoreNotGreater value: " + value));
    }
}

Schauen wir uns die wichtigsten Änderungen an:

import java.util.Optional;: Wir importieren die Optional-Klasse.
Optional<Integer> optionalScoreNull = Optional.empty();: Wir erstellen ein leeres Optional, um das Fehlen eines Werts darzustellen.
Optional<Integer> optionalScorePresent = Optional.of(75);: Wir erstellen ein Optional, das einen nicht-null-Wert enthält, indem wir Optional.of() verwenden. Beachten Sie, dass Optional.of() eine NullPointerException wirft, wenn Sie ihm einen null-Wert übergeben. Wenn der Wert null sein kann, verwenden Sie Optional.ofNullable().
optionalScoreNull.isPresent(): Diese Methode prüft, ob das Optional einen Wert enthält. Sie ist die empfohlene Methode, um auf das Vorhandensein eines Werts zu prüfen, anstatt auf null zu prüfen.
optionalScoreNull.get(): Diese Methode ruft den Wert aus dem Optional ab. Achten Sie auf! Wenn das Optional leer ist, wird beim Aufruf von get() eine NoSuchElementException ausgelöst. Deshalb sollten Sie immer isPresent() prüfen, bevor Sie get() aufrufen, oder andere Optional-Methoden verwenden, die den Fall eines leeren Optional gracefully behandeln.
optionalScoreNull.ifPresent(value -> ...): Diese Methode führt den angegebenen Code nur aus, wenn das Optional einen Wert enthält. Sie ist eine saubere Methode, um eine Aktion auf dem Wert auszuführen, wenn er vorhanden ist.
optionalScoreNull.orElse(0): Diese Methode gibt den Wert zurück, wenn er vorhanden ist, andernfalls gibt sie den angegebenen Standardwert (in diesem Fall 0) zurück.
optionalScorePresent.filter(value -> value > 50): Diese Methode gibt ein Optional zurück, das den Wert enthält, wenn er vorhanden ist UND die angegebene Bedingung erfüllt (Wert > 50), andernfalls gibt sie ein leeres Optional zurück.

Speichern Sie die Datei HelloJava.java.
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
optionalScoreNull is empty or not greater than 50.
optionalScorePresent is present and greater than 50.
optionalScoreNotGreater is empty or not greater than 50.

Using Optional methods:
Value from optionalScorePresent: 75
Value from optionalScoreNotGreater: 40
Value from optionalScoreNull with default: 0
Filtered optionalScorePresent value: 75
```
Diese Ausgabe zeigt, wie Optional verwendet werden kann, um das Vorhandensein oder Fehlen von Werten zu verarbeiten und Operationen sicher auszuführen. Während das Muster if (isPresent() && get() > 50) ähnlich der null-Prüfung ist, bietet Optional viele andere nützliche Methoden (ifPresent, orElse, filter, map usw.), die zu einem ausdrucksstärkeren und sichereren Code führen können, wenn es um möglicherweise fehlende Werte geht. Die Verwendung von Optional ist eine gute Praxis in der modernen Java-Entwicklung.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein Integer-Wrapper-Objekt in Java null ist. Wir haben zunächst verstanden, dass Integer eine Klasse ist und einen null-Verweis enthalten kann, im Gegensatz zum primitiven int. Wir haben die grundlegende == null-Prüfung anhand eines einfachen Java-Programms demonstriert und gezeigt, wie man sowohl null- als auch nicht-null-Integer-Variablen behandelt, um NullPointerException zu vermeiden.