Wie man prüft, ob eine ArrayList in Java null ist

Einführung

In diesem Lab werden wir verschiedene Techniken untersuchen, um zu prüfen, ob ein ArrayList in Java null ist. Die Behandlung von Nullwerten ist ein grundlegendes Aspekt des robusten Java-Programmierens, und es ist unerlässlich, zu verstehen, wie man dies korrekt macht, um NullPointerException-Fehler zu vermeiden.

Wir beginnen damit, die einfachste Methode zu untersuchen, die den Gleichheitsoperator (==) verwendet, um direkt auf null zu prüfen. Danach werden wir lernen, wie man Nullprüfungen mit Prüfungen auf eine leere Liste kombiniert, um beide Szenarien effektiv zu behandeln. Schließlich werden wir die Verwendung der Optional-Klasse untersuchen, ein modernes Java-Feature, das eine ausdrucksstärkere und sicherere Möglichkeit bietet, potenziell Nullwerte zu behandeln.

Prüfung auf Null mit dem Gleichheitsoperator

In diesem Schritt werden wir die einfachste Methode untersuchen, um zu prüfen, ob eine Variable in Java einen null-Wert enthält: die Verwendung des Gleichheitsoperators (==). Das Verständnis, wie man null behandelt, ist in der Java-Programmierung von entscheidender Bedeutung, um Fehler zu vermeiden.

In Java ist null ein spezieller Wert, der angibt, dass eine Variable auf kein Objekt verweist. Stellen Sie sich das wie eine leere Schachtel vor – die Schachtel existiert, aber es ist nichts darin. Wenn Sie versuchen, eine Variable, die null ist, so zu verwenden, als ob sie auf ein Objekt verweisen würde (z. B. indem Sie eine Methode auf ihr aufrufen), erhalten Sie eine NullPointerException, was ein sehr häufiger Fehler in Java ist.

Der Gleichheitsoperator (==) wird verwendet, um zwei Werte zu vergleichen. Wenn Sie einen Objektverweis mit null vergleichen, prüft ==, ob der Verweis auf den null-Wert zeigt.

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

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        String message = null; // Deklarieren einer String-Variable und Setzen auf null

        // Prüfen, ob die message-Variable null ist
        if (message == null) {
            System.out.println("The message is null.");
        } else {
            System.out.println("The message is not null: " + message);
        }

        message = "Hello, World!"; // Zuweisen eines String-Objekts an die Variable

        // Wiederholtes Prüfen nach der Zuweisung eines Werts
        if (message == null) {
            System.out.println("The message is null.");
        } else {
            System.out.println("The message is not null: " + message);
        }
    }
}

In diesem Code:

Wir deklarieren eine String-Variable namens message und setzen sie zunächst auf null.
Wir verwenden eine if-Anweisung mit der Bedingung message == null, um zu prüfen, ob die Variable null ist.
Wir geben eine Nachricht aus, die angibt, ob die Variable null ist oder nicht.
Wir weisen dann einen tatsächlichen String-Wert ("Hello, World!") der message-Variable zu.
Wir führen die null-Prüfung erneut durch, um den Unterschied zu sehen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm mit dem Befehl javac im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird die Kompilierung ohne Meldung abgeschlossen.
Führen Sie das kompilierte Programm mit dem Befehl java aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
The message is null.
The message is not null: Hello, World!
```
Diese Ausgabe bestätigt, dass die Prüfung == null korrekt erkannt hat, wann die message-Variable null war und wann sie einen Wert hatte.

Die Verwendung des Gleichheitsoperators (==) ist die einfachste Methode, um in Java auf null zu prüfen. Es ist jedoch wichtig zu beachten, dass dies nur für die Prüfung, ob ein Verweis null ist, funktioniert. Es prüft nicht, ob ein String leer ist (keine Zeichen enthält, wie ""). Wir werden im nächsten Schritt untersuchen, wie man leere Strings behandelt.

Kombinieren von Null- und Leerheitsprüfungen

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob eine Variable null ist, indem man den ==-Operator verwendet. In Java, insbesondere wenn es um String-Objekte geht, ist es jedoch oft notwendig, nicht nur zu prüfen, ob eine Variable null ist, sondern auch, ob sie "leer" ist. Ein leerer String ist ein String-Objekt, das existiert, aber keine Zeichen enthält (z. B. ""). Ein null-String hingegen bedeutet, dass die Variable überhaupt nicht auf ein String-Objekt verweist.

Wenn Sie versuchen, Methoden wie isEmpty() oder length() auf einem null-String aufzurufen, wird eine NullPointerException ausgelöst. Wenn Sie also null-Strings und leere Strings gleich behandeln möchten (z. B. als "leer" oder "fehlend" betrachten), müssen Sie beide Bedingungen prüfen.

Die gebräuchlichste Methode dazu besteht darin, zunächst zu prüfen, ob der String null ist und dann, wenn er nicht null ist, zu prüfen, ob er leer ist, indem Sie die isEmpty()-Methode verwenden.

Lassen Sie uns unser HelloJava.java-Programm ändern, um die Kombination dieser Prüfungen zu demonstrieren.

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

Ersetzen Sie den aktuellen Code durch folgenden:

public class HelloJava {
    public static void main(String[] args) {
        String text1 = null;
        String text2 = ""; // Ein leerer String
        String text3 = "Hello"; // Ein nicht-leerer String

        System.out.println("Checking text1 (null):");
        if (text1 == null || text1.isEmpty()) {
            System.out.println("text1 is null or empty.");
        } else {
            System.out.println("text1 is not null and not empty: " + text1);
        }

        System.out.println("\nChecking text2 (empty):");
        // Es ist wichtig, zunächst auf null zu prüfen!
        if (text2 == null || text2.isEmpty()) {
            System.out.println("text2 is null or empty.");
        } else {
            System.out.println("text2 is not null and not empty: " + text2);
        }

        System.out.println("\nChecking text3 (not empty):");
        if (text3 == null || text3.isEmpty()) {
            System.out.println("text3 is null or empty.");
        } else {
            System.out.println("text3 is not null and not empty: " + text3);
        }
    }
}

In diesem aktualisierten Code:

Wir führen drei String-Variablen ein: text1 (null), text2 (leer) und text3 (nicht leer).
Wir verwenden den logischen ODER-Operator (||), um die null-Prüfung (text == null) und die Leerheitsprüfung (text.isEmpty()) zu kombinieren.
Die Bedingung text == null || text.isEmpty() ist wahr, wenn text entweder null ist ODER wenn text nicht null ist UND text.isEmpty() wahr ist.
Wichtig: Die null-Prüfung (text == null) muss in der ||-Bedingung zuerst stehen. Wenn text null ist, ist der erste Teil der ||-Bedingung (text == null) wahr, und Java verwendet die "Short-Circuit-Evaluation", um den zweiten Teil (text.isEmpty()) zu überspringen, wodurch eine NullPointerException vermieden wird. Wenn die isEmpty()-Prüfung zuerst stünde und text null wäre, würde dies einen Fehler verursachen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Checking text1 (null):
text1 is null or empty.

Checking text2 (empty):
text2 is null or empty.

Checking text3 (not empty):
text3 is not null and not empty: Hello
```
Diese Ausgabe zeigt, dass unsere kombinierte Prüfung sowohl den null-String (text1) als auch den leeren String (text2) korrekt als "null oder leer" identifiziert hat, während der nicht-leere String (text3) ebenfalls korrekt identifiziert wurde.

Diese kombinierte Prüfung (string == null || string.isEmpty()) ist ein sehr häufiges Muster in Java, wenn Sie sowohl null- als auch leere Strings behandeln müssen. Viele Bibliotheken bieten auch Hilfsmethoden für diese Aufgabe an, wie z. B. StringUtils.isEmpty() oder StringUtils.isBlank() (die auch auf Leerzeichen prüft) in Apache Commons Lang, aber das Verständnis der grundlegenden kombinierten Prüfung ist von grundlegender Bedeutung.

Verwenden von Optional für sichere Handhabung

Während die Prüfung auf null und leere Strings mit == null || isEmpty() effektiv ist, hat Java 8 die Optional-Klasse eingeführt, um potenziell fehlende Werte expliziter und sicherer zu behandeln. Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder auch nicht. Durch die Verwendung von Optional können Sie NullPointerExceptions vermeiden und Ihren Code lesbarer gestalten, indem Sie deutlich machen, dass ein Wert fehlen kann.

Optional ersetzt die null-Prüfungen nicht vollständig, sondern bietet eine funktionalere und ausdrucksstärkere Möglichkeit, Situationen zu behandeln, in denen ein Wert fehlen kann.

Lassen Sie uns sehen, wie man Optional in unserem HelloJava.java-Programm verwendet.

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

Ersetzen Sie den aktuellen Code durch folgenden:

import java.util.Optional;

public class HelloJava {
    public static void main(String[] args) {
        String text1 = null;
        String text2 = "";
        String text3 = "Hello";

        // Erstellen von Optional-Objekten
        Optional<String> optionalText1 = Optional.ofNullable(text1);
        Optional<String> optionalText2 = Optional.ofNullable(text2);
        Optional<String> optionalText3 = Optional.ofNullable(text3);

        System.out.println("Checking optionalText1 (from null):");
        // Prüfen, ob ein Wert vorhanden ist
        if (optionalText1.isPresent()) {
            System.out.println("optionalText1 contains a value: " + optionalText1.get());
        } else {
            System.out.println("optionalText1 is empty (no value present).");
        }

        System.out.println("\nChecking optionalText2 (from empty string):");
        if (optionalText2.isPresent()) {
            System.out.println("optionalText2 contains a value: " + optionalText2.get());
        } else {
            System.out.println("optionalText2 is empty (no value present).");
        }

        System.out.println("\nChecking optionalText3 (from non-empty string):");
        if (optionalText3.isPresent()) {
            System.out.println("optionalText3 contains a value: " + optionalText3.get());
        } else {
            System.out.println("optionalText3 is empty (no value present).");
        }

        // Verwenden von orElse(), um einen Standardwert bereitzustellen, wenn das Optional leer ist
        String valueOrDefault1 = optionalText1.orElse("Default Value 1");
        String valueOrDefault2 = optionalText2.orElse("Default Value 2");
        String valueOrDefault3 = optionalText3.orElse("Default Value 3");

        System.out.println("\nUsing orElse():");
        System.out.println("Value from optionalText1: " + valueOrDefault1);
        System.out.println("Value from optionalText2: " + valueOrDefault2);
        System.out.println("Value from optionalText3: " + valueOrDefault3);
    }
}

Lassen Sie uns die neuen Teile analysieren:

import java.util.Optional;: Wir müssen die Optional-Klasse importieren.
Optional.ofNullable(text);: Dies ist die empfohlene Methode, um ein Optional aus einer Variable zu erstellen, die null sein kann. Wenn text null ist, wird ein leeres Optional erstellt. Wenn text nicht null ist, wird ein Optional erstellt, das den Wert von text enthält.
optionalText.isPresent(): Diese Methode gibt true zurück, wenn das Optional einen nicht-null-Wert enthält, und false sonst. Dies ist eine sichere Methode, um zu prüfen, ob ein Wert vorhanden ist, bevor Sie versuchen, auf ihn zuzugreifen.
optionalText.get(): Diese Methode gibt den im Optional enthaltenen Wert zurück. Verwenden Sie diese Methode mit Vorsicht! Wenn das Optional leer ist (d. h., isPresent() ist false), löst der Aufruf von get() eine NoSuchElementException aus. Es ist im Allgemeinen besser, andere Optional-Methoden wie orElse(), orElseGet() oder ifPresent() zu verwenden.
optionalText.orElse("Default Value"): Diese Methode gibt den im Optional enthaltenen Wert zurück, wenn er vorhanden ist. Wenn das Optional leer ist, gibt sie stattdessen den angegebenen Standardwert zurück. Dies ist eine sichere und bequeme Möglichkeit, einen Fallback-Wert bereitzustellen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Checking optionalText1 (from null):
optionalText1 is empty (no value present).

Checking optionalText2 (from empty string):
optionalText2 contains a value:

Checking optionalText3 (from non-empty string):
optionalText3 contains a value: Hello

Using orElse():
Value from optionalText1: Default Value 1
Value from optionalText2:
Value from optionalText3: Hello
```
Beachten Sie, dass optionalText1 (aus null erstellt) korrekt als leer identifiziert wird. optionalText2 (aus einem leeren String "" erstellt) ist im Sinne von Optional nicht leer, da es ein gültiges String-Objekt enthält (auch wenn dieser String leer ist). optionalText3 enthält den String "Hello". Die Beispiele mit orElse() zeigen, wie Sie einfach Standardwerte bereitstellen können, wenn das Optional leer ist.

Die Verwendung von Optional kann Ihren Code robuster und ausdrucksstärker gestalten, wenn es um Werte geht, die fehlen können. Es ermutigt Sie, an die Möglichkeit eines fehlenden Werts zu denken und ihn explizit zu behandeln, wodurch die Wahrscheinlichkeit von unerwarteten NullPointerExceptions verringert wird.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java grundsätzlich prüft, ob eine Variable, insbesondere eine ArrayList, null ist, indem man den Gleichheitsoperator (==) verwendet. Wir haben verstanden, dass null die Abwesenheit einer Objektreferenz bedeutet und dass der Versuch, eine null-Variable zu verwenden, zu einer NullPointerException führen kann. Wir haben diese grundlegende Null-Prüfung in einem einfachen Java-Programm geübt.

Wir haben auch robusterere Techniken zur Behandlung potenzieller Null-Werte und leerer Sammlungen (Collections) untersucht. Dies umfasste die Kombination von Null- und Leerheitsprüfungen, um sicherzustellen, dass beide Bedingungen berücksichtigt werden, sowie die Verwendung der Optional-Klasse für einen moderneren und sichereren Ansatz zur Behandlung potenziell fehlender Werte, was zu einem lesbareren und fehlerunanfälligeren Code führt.