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. Wir werden drei Schlüsseltechniken untersuchen: die Verwendung der Methode length() zur Überprüfung der Stringlänge, die Nutzung der speziellen Methode isEmpty() für eine direkte Prüfung und vor allem die Behandlung möglicher Null-Strings, bevor Sie die Leerheitsprüfung durchführen, um Fehler zu vermeiden. Am Ende dieses Labs werden Sie einen soliden Überblick darüber haben, wie Sie in Ihren Java-Programmen effektiv die Leerheit von Strings bestimmen können.

Skills Graph

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

Überprüfen der Stringlänge mit der Methode `length()`

In diesem Schritt werden wir untersuchen, wie man in Java die Länge eines Strings mithilfe der eingebauten Methode length() bestimmt. Das Verständnis der Stringlänge ist ein grundlegendes Konzept, wenn man mit Textdaten in einer beliebigen Programmiersprache arbeitet.

In Java ist ein String eine Folge von Zeichen. Die Methode length() ist eine einfache Möglichkeit, herauszufinden, wie viele Zeichen in einem String enthalten sind. Es ist wie das Zählen der Buchstaben in einem Wort oder der Wörter in einem Satz.

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 den folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        String greeting = "Hello, Java!";
        int length = greeting.length();
        System.out.println("The string is: " + greeting);
        System.out.println("The length of the string is: " + length);
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- String greeting = "Hello, Java!";: Diese Zeile deklariert eine Variable namens greeting und weist ihr den Stringwert "Hello, Java!" zu.
- int length = greeting.length();: Hier verwenden wir die Methode length(). Wir rufen length() auf dem greeting-String auf, und es gibt die Anzahl der Zeichen in diesem String zurück. Diese Zahl wird dann in einer Ganzzahlvariablen namens length gespeichert.
- System.out.println("The string is: " + greeting);: Diese Zeile gibt den ursprünglichen String in der Konsole aus.
- System.out.println("The length of the string is: " + length);: Diese Zeile gibt die berechnete Länge des Strings aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt lassen Sie uns unser Programm kompilieren. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann den folgenden Befehl aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Schließlich lassen Sie uns das kompilierte Programm ausführen:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
The string is: Hello, Java!
The length of the string is: 12
```
Die Ausgabe zeigt den ursprünglichen String und seine Länge, die 12 beträgt (einschließlich Komma, Leerzeichen und Ausrufezeichen).

Sie haben erfolgreich die Methode length() verwendet, um die Länge eines Strings in Java zu ermitteln! Dies ist eine einfache, aber wichtige Operation, wenn man mit Textdaten arbeitet.

Prüfen auf leeren String mit der Methode `isEmpty()`

In diesem Schritt lernen wir, wie man in Java prüft, ob ein String leer ist, indem man die Methode isEmpty() verwendet. Ein leerer String ist ein String, der keine Zeichen enthält. Er unterscheidet sich von einem String, der Leerzeichen oder andere Zeichen enthält.

Die Methode isEmpty() ist eine bequeme Möglichkeit, zu prüfen, ob ein String eine Länge von Null hat. Sie gibt true zurück, wenn der String leer ist, und false sonst.

Lassen Sie uns unser HelloJava.java-Programm ändern, um die Methode isEmpty() zu demonstrieren.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class HelloJava {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = ""; // This is an empty string
        String str3 = " "; // This string contains a space

        System.out.println("String 1: \"" + str1 + "\"");
        System.out.println("Is String 1 empty? " + str1.isEmpty());

        System.out.println("\nString 2: \"" + str2 + "\"");
        System.out.println("Is String 2 empty? " + str2.isEmpty());

        System.out.println("\nString 3: \"" + str3 + "\"");
        System.out.println("Is String 3 empty? " + str3.isEmpty());
    }
}

In diesem Code:

Wir deklarieren drei Strings: str1 mit Inhalt, str2, der leer ist, und str3, der ein Leerzeichen enthält.
Wir verwenden str1.isEmpty(), str2.isEmpty() und str3.isEmpty(), um zu prüfen, ob jeder String leer ist.
Die System.out.println()-Anweisungen geben den String und das Ergebnis der isEmpty()-Prüfung (true oder false) aus.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.
Führen Sie das Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
String 1: "Hello"
Is String 1 empty? false

String 2: ""
Is String 2 empty? true

String 3: " "
Is String 3 empty? false
```
Wie Sie sehen können, erkennt isEmpty() korrekt, dass str2 leer ist (true), aber nicht str1 oder str3 (false). Dies liegt daran, dass str3 ein Leerzeichen enthält, auch wenn es so aussieht, als könnte es leer sein.

Sie haben erfolgreich die Methode isEmpty() verwendet, um zu prüfen, ob Strings leer sind. Dies ist nützlich für die Validierung von Benutzereingaben oder die Verarbeitung von Textdaten, bei denen Sie Fälle von fehlenden oder leeren Strings behandeln müssen.

Umgang mit Null-Strings vor der Prüfung auf Leerheit

Im vorherigen Schritt haben wir gelernt, wie man die Methode isEmpty() verwendet, um zu prüfen, ob ein String leer ist. Es gibt jedoch in Java ein wichtiges Konzept namens null. Ein null-Wert bedeutet, dass eine Variable auf kein Objekt verweist. Wenn Sie versuchen, eine Methode wie isEmpty() auf einen null-String aufzurufen, stürzt Ihr Programm mit einer NullPointerException ab.

Es ist von entscheidender Bedeutung, null-Strings zu behandeln, bevor Sie versuchen, irgendeine Methode auf sie anzuwenden. Der sicherste Weg, dies zu tun, ist, zunächst zu prüfen, ob der String null ist.

Lassen Sie uns unser Programm ändern, um zu demonstrieren, wie man mit null-Strings umgeht.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class HelloJava {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "";
        String str3 = null; // This string is null

        System.out.println("Checking String 1: \"" + str1 + "\"");
        if (str1 != null && !str1.isEmpty()) {
            System.out.println("String 1 is not null and not empty.");
        } else {
            System.out.println("String 1 is null or empty.");
        }

        System.out.println("\nChecking String 2: \"" + str2 + "\"");
        if (str2 != null && !str2.isEmpty()) {
            System.out.println("String 2 is not null and not empty.");
        } else {
            System.out.println("String 2 is null or empty.");
        }

        System.out.println("\nChecking String 3: " + str3); // Note: printing null doesn't crash
        if (str3 != null && !str3.isEmpty()) {
            System.out.println("String 3 is not null and not empty.");
        } else {
            System.out.println("String 3 is null or empty.");
        }
    }
}

In diesem Code:

Wir führen einen null-String str3 ein.
Bevor wir isEmpty() aufrufen, prüfen wir zunächst, ob der String null ist, indem wir str != null verwenden.
Wir verwenden den logischen UND-Operator (&&), um die null-Prüfung und die isEmpty()-Prüfung zu kombinieren. Der Teil !str.isEmpty() wird nur ausgewertet, wenn str != null wahr ist, wodurch die NullPointerException verhindert wird.
Die if-Anweisung prüft, ob der String nicht null UND nicht leer ist.

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 eine Ausgabe ähnlich der folgenden sehen:
```
Checking String 1: "Hello"
String 1 is not null and not empty.

Checking String 2: ""
String 2 is null or empty.

Checking String 3: null
String 3 is null or empty.
```
Diese Ausgabe zeigt, dass unser Code korrekt erkennt, dass str1 weder null noch leer ist und dass str2 und str3 null oder leer sind, ohne dass das Programm abstürzt.

Indem Sie vor dem Aufruf von Methoden auf Strings auf null prüfen, machen Sie Ihre Java-Programme robuster und vermeiden häufige Fehler. Dies ist eine sehr wichtige Praxis in der Java-Programmierung.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob ein String leer ist. Wir haben zunächst die Methode length() untersucht, um die Anzahl der Zeichen in einem String zu bestimmen. Dies ist ein grundlegendes Konzept für die Arbeit mit Textdaten. Wir haben ein einfaches Java-Programm geschrieben, um zu demonstrieren, wie man length() verwendet und den String sowie seine Länge auf der Konsole ausgibt.

Wir werden weiterhin andere Methoden wie isEmpty() untersuchen und lernen, wie man mit Null-Strings umgeht, um robuste Prüfungen auf Leerheit in unseren Java-Programmen sicherzustellen.