Wie man prüft, ob ein String in Java null ist

Einführung

In diesem Lab werden Sie essentielle Techniken zum Umgang mit Null-Strings in Java lernen. Wir beginnen damit, die grundlegende Methode zur Prüfung auf Null mithilfe des Gleichheitsoperators (==) zu untersuchen und zu verstehen, warum dies von entscheidender Bedeutung ist, um NullPointerException zu vermeiden.

Auf dieser Grundlage werden Sie lernen, wie Sie Null-Prüfungen mit Prüfungen auf leere Strings kombinieren können, um verschiedene String-Zustände effektiv zu behandeln. Abschließend werden wir die Optional-Klasse als moderne und sicherere Methode zur Verwaltung potenziell null-Werte einführen und zeigen, wie sie die Lesbarkeit des Codes verbessern und häufige Fehler vermeiden kann.

Prüfung auf null mit dem Gleichheitsoperator

In diesem Schritt werden Sie lernen, wie Sie in Java überprüfen können, ob eine String-Variable null ist, indem Sie den Gleichheitsoperator (==) verwenden. Das Verständnis, wie man null behandelt, ist in der Java-Programmierung von entscheidender Bedeutung, um Fehler zu vermeiden.

In Java kann eine Variable eines Referenztyps (wie String) einen speziellen Wert namens null enthalten. Dies bedeutet, dass die Variable auf kein Objekt im Speicher verweist. Wenn Sie versuchen, eine null-Variable als gültiges Objekt zu verwenden, wird eine NullPointerException ausgelöst, was für Anfänger ein häufiger und frustrierender Fehler ist.

Der einfachste Weg, um zu prüfen, ob ein String null ist, ist die Verwendung des Gleichheitsoperators (==).

Erstellen wir ein einfaches Java-Programm, um dies zu demonstrieren.

Öffnen Sie die WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Sie können dies überprüfen, indem Sie auf die Terminalaufforderung schauen oder pwd eingeben und Enter drücken.
Erstellen Sie in dem Verzeichnis ~/project eine neue Java-Datei mit dem Namen NullCheck.java. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken, "Neue Datei" auswählen und NullCheck.java eingeben.

Öffnen Sie die Datei NullCheck.java im Editor und fügen Sie den folgenden Code ein:

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // Dies ist ein leerer String, nicht null

        System.out.println("Checking myString1:");
        if (myString1 == null) {
            System.out.println("myString1 is null");
        } else {
            System.out.println("myString1 is not null");
        }

        System.out.println("\nChecking myString2:");
        if (myString2 == null) {
            System.out.println("myString2 is null");
        } else {
            System.out.println("myString2 is not null");
        }

        System.out.println("\nChecking myString3:");
        if (myString3 == null) {
            System.out.println("myString3 is null");
        } else {
            System.out.println("myString3 is not null");
        }
    }
}

In diesem Code:

Wir deklarieren drei String-Variablen: myString1 wird einen regulären String zugewiesen, myString2 wird explizit null zugewiesen und myString3 wird ein leerer String ("") zugewiesen.
Wir verwenden eine if-Anweisung mit dem Gleichheitsoperator (==), um zu prüfen, ob jeder String null ist.
Wir geben eine Nachricht aus, die angibt, ob der String null ist oder nicht.

Speichern Sie die Datei NullCheck.java (Strg+S oder Cmd+S).
Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie das Java-Programm mit dem Befehl javac:
```
javac NullCheck.java
```
Wenn keine Fehler auftreten, wird dieser Befehl eine Datei namens NullCheck.class im gleichen Verzeichnis erstellen.

Führen Sie das kompilierte Java-Programm mit dem Befehl java aus:

java NullCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking myString1:
myString1 is not null

Checking myString2:
myString2 is null

Checking myString3:
myString3 is not null

Diese Ausgabe bestätigt, dass myString1 und myString3 nicht null sind, während myString2 null ist. Es ist wichtig, den Unterschied zwischen einem null-String und einem leeren String ("") zu beachten. Ein leerer String ist ein gültiges String-Objekt mit null Zeichen, während eine null-String-Variable auf kein Objekt verweist.

Die Verwendung von == null ist der Standard- und korrekte Weg, um in Java zu prüfen, ob eine Referenzvariable null ist.

Kombinieren von Prüfungen auf null und leere Strings

Im vorherigen Schritt haben wir gelernt, wie man prüft, ob ein String null ist. In vielen realen Szenarien müssen Sie jedoch möglicherweise auch prüfen, ob ein String leer ist (keine Zeichen enthält) oder nur Leerzeichen enthält. Ein String, der null, leer oder nur Leerzeichen enthält, wird oft als "leer" oder "tatsächlich leer" angesehen.

Das Prüfen auf sowohl null als auch leere Strings ist eine häufige Anforderung. Sie können diese Prüfungen mithilfe des logischen ODER-Operators (||) kombinieren.

Ändern wir unser vorheriges Programm, um Prüfungen auf sowohl null als auch leere Strings einzubeziehen.

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

Modifizieren Sie die main-Methode, um einen leeren String einzubeziehen und die Prüfungen zu kombinieren. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = ""; // Dies ist ein leerer String
        String myString4 = "   "; // Dieser String enthält nur Leerzeichen

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

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

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

        System.out.println("\nChecking myString4:");
        // Hinweis: isEmpty() prüft nicht auf Leerzeichen
        if (myString4 == null || myString4.isEmpty()) {
            System.out.println("myString4 is null or empty");
        } else {
            System.out.println("myString4 is not null and not empty");
        }
    }
}

In diesem aktualisierten Code:

Wir haben myString4 hinzugefügt, das nur Leerzeichen enthält.
Wir verwenden die Bedingung myString == null || myString.isEmpty(), um zu prüfen, ob ein String entweder null oder leer ist. Die isEmpty()-Methode ist eine integrierte String-Methode, die true zurückgibt, wenn der String eine Länge von 0 hat.
Wichtig: Die isEmpty()-Methode kann nur auf einem nicht-null-String aufgerufen werden. Wenn Sie versuchen, isEmpty() auf einem null-String aufzurufen, erhalten Sie eine NullPointerException. Daher ist es wichtig, zuerst auf null zu prüfen, indem Sie myString == null verwenden, bevor Sie myString.isEmpty() aufrufen. Der logische ODER-Operator (||) ist "kurzschlussfähig", was bedeutet, dass wenn die erste Bedingung (myString == null) wahr ist, die zweite Bedingung (myString.isEmpty()) nicht ausgewertet wird, wodurch die NullPointerException vermieden wird.

Speichern Sie die Datei NullCheck.java.
Kompilieren Sie das modifizierte Programm im Terminal:
```
javac NullCheck.java
```

Führen Sie das kompilierte Programm aus:

java NullCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking myString1:
myString1 is not null and not empty

Checking myString2:
myString2 is null or empty

Checking myString3:
myString3 is null or empty

Checking myString4:
myString4 is not null and not empty

Beachten Sie, dass myString4 (das nur Leerzeichen enthält) von dieser Prüfung als "nicht null und nicht leer" angesehen wird. Wenn Sie auch Strings mit nur Leerzeichen als "leer" betrachten müssen, können Sie die isBlank()-Methode verwenden (ab Java 11 verfügbar).

Lassen Sie uns den Code schnell aktualisieren, um isBlank() für myString4 zu verwenden:

Modifizieren Sie die Prüfung für myString4 in NullCheck.java:

// ... (vorheriger Code) ...

        System.out.println("\nChecking myString4 with isBlank():");
        if (myString4 == null || myString4.isBlank()) {
            System.out.println("myString4 is null or blank");
        } else {
            System.out.println("myString4 is not null and not blank");
        }
    }
}

Speichern Sie die Datei, kompilieren Sie und führen Sie es erneut aus:
```
javac NullCheck.java
java NullCheck
```
Die Ausgabe für myString4 sollte jetzt wie folgt lauten:
```
Checking myString4 with isBlank():
myString4 is null or blank
```

Dies zeigt, wie man Prüfungen auf null und leere/leere Strings kombiniert, was ein sehr häufiges Muster in der Java-Programmierung ist.

Verwenden von Optional zum sicheren Umgang mit null-Strings

In den vorherigen Schritten haben wir den Gleichheitsoperator (==) sowie die Methoden isEmpty() oder isBlank() verwendet, um auf null und leere/leere Strings zu prüfen. Obwohl diese Methoden effektiv sind, hat Java 8 die Optional-Klasse eingeführt, um potenziell null-Werte auf eine explizitere und funktionale Weise zu behandeln. Die Verwendung von Optional kann dazu beitragen, dass Ihr Code lesbarer wird und weniger anfällig für NullPointerExceptions ist.

Optional ist ein Containerobjekt, das einen nicht-null-Wert enthalten kann oder nicht. Wenn ein Wert vorhanden ist, gibt isPresent() true zurück und get() gibt den Wert zurück. Wenn kein Wert vorhanden ist, wird das Objekt als leer angesehen und isPresent() gibt false zurück. Das Aufrufen von get() auf einem leeren Optional löst eine NoSuchElementException aus.

Lassen Sie uns untersuchen, wie man Optional mit Strings verwendet.

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

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code, der Optional verwendet:

import java.util.Optional;

public class NullCheck {

    public static void main(String[] args) {

        String myString1 = "Hello";
        String myString2 = null;
        String myString3 = "";
        String myString4 = "   ";

        // Erstellen von Optional-Objekten aus Strings
        Optional<String> optionalString1 = Optional.ofNullable(myString1);
        Optional<String> optionalString2 = Optional.ofNullable(myString2);
        Optional<String> optionalString3 = Optional.ofNullable(myString3);
        Optional<String> optionalString4 = Optional.ofNullable(myString4);

        System.out.println("Checking optionalString1:");
        if (optionalString1.isPresent()) {
            System.out.println("optionalString1 has a value: " + optionalString1.get());
        } else {
            System.out.println("optionalString1 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString2:");
        if (optionalString2.isPresent()) {
            System.out.println("optionalString2 has a value: " + optionalString2.get());
        } else {
            System.out.println("optionalString2 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString3:");
        // Optional.ofNullable("") erstellt ein Optional, das einen leeren String enthält
        if (optionalString3.isPresent()) {
            System.out.println("optionalString3 has a value: " + optionalString3.get());
        } else {
            System.out.println("optionalString3 is empty (contains null)");
        }

        System.out.println("\nChecking optionalString4:");
         if (optionalString4.isPresent()) {
            System.out.println("optionalString4 has a value: " + optionalString4.get());
        } else {
            System.out.println("optionalString4 is empty (contains null)");
        }

        // Verwendung von Optional-Methoden für eine sicherere Behandlung
        System.out.println("\nUsing Optional methods:");

        // orElse: liefert einen Standardwert, wenn das Optional leer ist
        String value1 = optionalString1.orElse("Default Value");
        String value2 = optionalString2.orElse("Default Value");
        System.out.println("Value from optionalString1 (orElse): " + value1);
        System.out.println("Value from optionalString2 (orElse): " + value2);

        // ifPresent: führt eine Aktion aus, wenn ein Wert vorhanden ist
        System.out.print("If optionalString1 is present: ");
        optionalString1.ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("If optionalString2 is present: ");
        optionalString2.ifPresent(s -> System.out.println("Value is " + s));

        // filter: filtert den Wert, wenn er vorhanden ist
        System.out.print("Filtered optionalString1 (length > 3): ");
        optionalString1.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));

        System.out.print("Filtered optionalString3 (length > 3): ");
        optionalString3.filter(s -> s.length() > 3).ifPresent(s -> System.out.println("Value is " + s));
    }
}

In diesem Code:

Wir importieren die Optional-Klasse.
Wir verwenden Optional.ofNullable(string), um ein Optional<String> aus einem regulären String zu erstellen. Diese Methode kann sicher verwendet werden, auch wenn der Eingabestring null ist. Wenn die Eingabe null ist, gibt sie ein leeres Optional zurück; andernfalls gibt sie ein Optional zurück, das den String enthält.
Wir verwenden optionalString.isPresent(), um zu prüfen, ob das Optional einen Wert enthält.
Wir verwenden optionalString.get(), um den Wert abzurufen, wenn er vorhanden ist. Achtung: Das Aufrufen von get() auf einem leeren Optional löst eine Ausnahme aus, also prüfen Sie immer zuerst isPresent() oder verwenden Sie andere sicherere Methoden.
Wir demonstrieren orElse(defaultValue), das den enthaltenen Wert zurückgibt, wenn er vorhanden ist, andernfalls den angegebenen Standardwert.
Wir demonstrieren ifPresent(consumer), das die angegebene Aktion (eine Funktion, die ein Argument nimmt und kein Ergebnis zurückgibt) ausführt, wenn ein Wert vorhanden ist.
Wir demonstrieren filter(predicate), das ein Optional zurückgibt, das den Wert enthält, wenn er vorhanden ist und der angegebenen Bedingung (eine Funktion, die einen booleschen Wert zurückgibt) entspricht, andernfalls ein leeres Optional.

Speichern Sie die Datei NullCheck.java.
Kompilieren Sie das Programm im Terminal:
```
javac NullCheck.java
```

Führen Sie das Programm aus:

java NullCheck

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Checking optionalString1:
optionalString1 has a value: Hello

Checking optionalString2:
optionalString2 is empty (contains null)

Checking optionalString3:
optionalString3 has a value:

Checking optionalString4:
optionalString4 has a value:

Using Optional methods:
Value from optionalString1 (orElse): Hello
Value from optionalString2 (orElse): Default Value
If optionalString1 is present: Value is Hello
If optionalString2 is present:
Filtered optionalString1 (length > 3): Value is Hello
Filtered optionalString3 (length > 3):

Die Verwendung von Optional kann Ihren Code ausdrucksstärker machen, wenn es darum geht, ob ein Wert fehlen kann, und bietet nützliche Methoden zur Behandlung des Vorhandenseins oder Fehlens eines Werts ohne explizite null-Prüfungen überall. Obwohl Optional ein leistungsfähiges Werkzeug ist, ist es keine Ersetzung für alle null-Prüfungen, aber es ist besonders nützlich, wenn es um Rückgabewerte geht, die null sein können.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein String in Java null ist. Wir begannen damit, den Gleichheitsoperator (==) zu verwenden, um eine String-Variable direkt mit null zu vergleichen. Wir verstehen nun, dass null die Abwesenheit einer Objektreferenz bedeutet und dass das Fehlen einer null-Prüfung zu einer NullPointerException führen kann.

Anschließend haben wir untersucht, wie man die null-Prüfung mit einer Prüfung auf einen leeren String kombiniert. Wir haben erkannt, dass ein leerer String ("") ein gültiges Objekt ist, im Gegensatz zu null. Schließlich haben wir gelernt, wie man die Optional-Klasse, die in Java 8 eingeführt wurde, als eine modernere und sicherere Methode zur Behandlung potenziell null-Werte einsetzt. Dies fördert robusteren und lesbareren Code, indem es explizit die Möglichkeit eines fehlenden Werts anzeigt.