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

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob ein String leer ist. Sie werden die isBlank()-Methode kennenlernen, die in Java 11 eingeführt wurde und effizient feststellt, ob ein String leer ist oder nur Leerzeichen enthält.

Anhand praktischer Beispiele werden Sie zunächst isBlank() verwenden, um verschiedene String-Typen zu prüfen. Anschließend lernen Sie, wie Sie isBlank() mit einer Null-Prüfung kombinieren können, um eine robuste String-Validierung durchzuführen. Abschließend vergleichen Sie das Verhalten von isBlank() und isEmpty(), um deren wesentlichen Unterschiede zu verstehen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/StringManipulationGroup -.-> java/strings("Strings") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/if_else -.-> lab-559985{{"Wie man prüft, ob ein String in Java leer ist"}} java/strings -.-> lab-559985{{"Wie man prüft, ob ein String in Java leer ist"}} java/string_methods -.-> lab-559985{{"Wie man prüft, ob ein String in Java leer ist"}} end

Verwendung von `isBlank()` zur Prüfung auf leere Strings

In diesem Schritt lernen Sie, wie Sie die isBlank()-Methode in Java verwenden, um zu prüfen, ob ein String leer ist. Ein leerer String ist ein String, der nur Leerzeichen (Leerzeichen, Tabulatoren, Zeilenumbrüche) enthält oder leer ist.

Die isBlank()-Methode wurde in Java 11 eingeführt und ist eine bequeme Möglichkeit, leere Strings zu prüfen. Sie gibt true zurück, wenn der String leer ist oder nur Leerzeichen enthält, und false sonst.

Erstellen wir ein einfaches Java-Programm, um die isBlank()-Methode 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 str1 = ""; // Leerer String
        String str2 = "   "; // String mit nur Leerzeichen
        String str3 = "Hello"; // Nicht-leerer String
        String str4 = " Hello "; // String mit führenden/nachfolgenden Leerzeichen

        System.out.println("Ist str1 leer? " + str1.isBlank());
        System.out.println("Ist str2 leer? " + str2.isBlank());
        System.out.println("Ist str3 leer? " + str3.isBlank());
        System.out.println("Ist str4 leer? " + str4.isBlank());
    }
}

In diesem Code:

Wir deklarieren vier verschiedene Strings: einen leeren String, einen String mit nur Leerzeichen, einen nicht-leeren String und einen String mit führenden/nachfolgenden Leerzeichen.
Wir verwenden str.isBlank(), um zu prüfen, ob jeder String leer ist, und geben das Ergebnis aus.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren wir das Programm. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Wenn nicht, verwenden Sie den Befehl cd ~/project. Kompilieren Sie dann den Code mit dem javac-Befehl:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, wird im Verzeichnis ~/project eine Datei HelloJava.class erstellt.
Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Ist str1 leer? true
Ist str2 leer? true
Ist str3 leer? false
Ist str4 leer? false
```
Wie Sie sehen können, erkennt isBlank() korrekt den leeren String (str1) und den String mit nur Leerzeichen (str2) als leer, während str3 und str4 als nicht-leer angesehen werden, da sie nicht-Leerzeichen enthalten.

Kombination von `isBlank()` mit einer Null-Prüfung

Im vorherigen Schritt haben Sie gelernt, wie Sie isBlank() verwenden können, um leere Strings oder Strings, die nur Leerzeichen enthalten, zu prüfen. Allerdings löst isBlank() eine NullPointerException aus, wenn die String-Variable null ist. In realen Anwendungen ist es üblich, auf null-Strings zu treffen, daher ist es wichtig, diese gracefully zu behandeln.

Um sicherzustellen, dass ein String entweder null oder leer ist, sollten Sie eine Null-Prüfung mit der isBlank()-Methode kombinieren. Die gebräuchlichste Methode dazu ist die Verwendung einer if-Anweisung:

if (str == null || str.isBlank()) {
    // Der String ist null oder leer
} else {
    // Der String ist weder null noch leer
}

Ändern wir unser Programm, um einen null-String einzubeziehen und zu demonstrieren, wie man ihn behandelt.

Ö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 str1 = ""; // Leerer String
        String str2 = "   "; // String mit nur Leerzeichen
        String str3 = "Hello"; // Nicht-leerer String
        String str4 = null; // Null-String

        System.out.println("Ist str1 null oder leer? " + (str1 == null || str1.isBlank()));
        System.out.println("Ist str2 null oder leer? " + (str2 == null || str2.isBlank()));
        System.out.println("Ist str3 null oder leer? " + (str3 == null || str3.isBlank()));
        System.out.println("Ist str4 null oder leer? " + (str4 == null || str4.isBlank()));
    }
}

In diesem aktualisierten Code:

Wir haben eine null-String-Variable str4 hinzugefügt.
Wir verwenden die Bedingung str == null || str.isBlank(), um zu prüfen, ob jeder String entweder null oder leer ist. Der ||-Operator bedeutet "oder". Wenn der erste Teil (str == null) wahr ist, wird der zweite Teil (str.isBlank()) gar nicht geprüft, was die NullPointerException verhindert.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
Ist str1 null oder leer? true
Ist str2 null oder leer? true
Ist str3 null oder leer? false
Ist str4 null oder leer? true
```
Diese Ausgabe zeigt, dass unsere kombinierte Prüfung den leeren String, den String mit Leerzeichen und den null-String korrekt als "null oder leer" identifiziert, während der nicht-leere String korrekt als "nicht null und nicht leer" identifiziert wird.

Das Kombinieren der Null-Prüfung mit isBlank() ist eine robuste Methode, um verschiedene String-Zustände in Ihren Java-Programmen zu behandeln.

Vergleich von `isBlank()` und `isEmpty()`

In den vorherigen Schritten haben Sie isBlank() verwendet, um Strings zu prüfen, die leer sind oder nur Leerzeichen enthalten. Möglicherweise haben Sie auch von der isEmpty()-Methode in Java gehört. In diesem Schritt vergleichen wir isBlank() und isEmpty(), um den Unterschied zwischen ihnen zu verstehen.

Die isEmpty()-Methode ist seit Java Version 1.0 verfügbar. Sie gibt nur dann true zurück, wenn der String eine Länge von 0 hat (d. h., es ist ein leerer String ""). Sie gibt false für alle anderen Strings zurück, einschließlich Strings, die nur Leerzeichen enthalten.

Ändern wir unser Programm ein letztes Mal, um sowohl isBlank() als auch isEmpty() zu verwenden und zu sehen, wie sie mit verschiedenen String-Typen reagieren.

Ö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 str1 = ""; // Leerer String
        String str2 = "   "; // String mit nur Leerzeichen
        String str3 = "Hello"; // Nicht-leerer String
        String str4 = null; // Null-String

        System.out.println("--- Verwendung von isBlank() ---");
        System.out.println("Ist str1 leer? " + (str1 == null || str1.isBlank()));
        System.out.println("Ist str2 leer? " + (str2 == null || str2.isBlank()));
        System.out.println("Ist str3 leer? " + (str3 == null || str3.isBlank()));
        // Hinweis: Wir müssen immer noch die Null-Prüfung vor dem Aufruf von isBlank() durchführen
        System.out.println("Ist str4 leer? " + (str4 == null || str4.isBlank()));

        System.out.println("\n--- Verwendung von isEmpty() ---");
        // Hinweis: Wir müssen auch eine Null-Prüfung vor dem Aufruf von isEmpty() durchführen
        System.out.println("Ist str1 leer? " + (str1 == null || str1.isEmpty()));
        System.out.println("Ist str2 leer? " + (str2 == null || str2.isEmpty()));
        System.out.println("Ist str3 leer? " + (str3 == null || str3.isEmpty()));
        System.out.println("Ist str4 leer? " + (str4 == null || str4.isEmpty()));
    }
}

In diesem Code:

Wir haben Abschnitte hinzugefügt, um sowohl isBlank() als auch isEmpty() zu demonstrieren.
Wir verwenden die kombinierte Null-Prüfung (str == null || ...) vor dem Aufruf von sowohl isBlank() als auch isEmpty(), um eine NullPointerException zu vermeiden.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten die folgende Ausgabe sehen:
```
--- Verwendung von isBlank() ---
Ist str1 leer? true
Ist str2 leer? true
Ist str3 leer? false
Ist str4 leer? true

--- Verwendung von isEmpty() ---
Ist str1 leer? true
Ist str2 leer? false
Ist str3 leer? false
Ist str4 leer? true
```
Aus der Ausgabe können Sie den wesentlichen Unterschied beobachten:
- isBlank() gibt true sowohl für leere Strings ("") als auch für Strings mit nur Leerzeichen (" ") zurück.
- isEmpty() gibt nur für leere Strings ("") true zurück. Sie gibt false für Strings mit nur Leerzeichen (" ") zurück.
Beide Methoden erfordern eine Null-Prüfung, bevor sie auf einen potenziell null-String angewendet werden.

Zusammenfassend:

Verwenden Sie isEmpty(), wenn Sie nur prüfen möchten, ob ein String eine Länge von Null hat.
Verwenden Sie isBlank(), wenn Sie prüfen möchten, ob ein String leer ist oder nur Leerzeichen enthält.

Das Verständnis des Unterschieds zwischen diesen beiden Methoden ist entscheidend für das Schreiben korrekten und robusten Codes zur String-Verarbeitung in Java.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie in Java überprüfen können, ob ein String leer ist, indem Sie die isBlank()-Methode verwenden, die in Java 11 eingeführt wurde. Sie haben die Verwendung von isBlank() für verschiedene Arten von Strings geübt, darunter leere Strings, Strings mit nur Leerzeichen und Strings mit Inhalt. Sie haben auch ein einfaches Java-Programm kompiliert und ausgeführt, um die Funktionalität von isBlank() zu demonstrieren.