So prüfen Sie, ob eine Zeichenkette in Java mit einem bestimmten Präfix beginnt

Einführung

In diesem Lab lernen Sie, wie Sie in Java überprüfen können, ob ein String mit einem bestimmten Präfix beginnt, indem Sie die Methode startsWith() verwenden. Diese praktische Übung führt Sie durch die Anwendung der Methode startsWith(), das Testen ihres Verhaltens in verschiedenen Fällen und das Verständnis, wie sie mit null- und leeren Präfixen umgeht. Am Ende dieses Labs können Sie diese grundlegende Technik zur Manipulation von Strings sicher anwenden.

Verwenden Sie startsWith() zur Prüfung des Präfixes

In diesem Schritt lernen Sie, wie Sie die Methode startsWith() in Java verwenden, um zu überprüfen, ob ein String mit einem bestimmten Präfix beginnt. Dies ist eine häufige Operation, wenn Sie Text basierend auf seinem Anfang verarbeiten müssen.

Die Methode startsWith() ist Teil der String-Klasse in Java. Sie nimmt ein String-Argument entgegen, das das Präfix ist, nach dem Sie suchen. Sie gibt true zurück, wenn der String mit dem angegebenen Präfix beginnt, und false sonst.

Erstellen wir eine neue Java-Datei, um die Verwendung von startsWith() zu üben.

Öffnen Sie den Dateiexplorer auf der linken Seite der WebIDE.
Klicken Sie mit der rechten Maustaste im Verzeichnis ~/project und wählen Sie "Neue Datei".
Benennen Sie die neue Datei PrefixChecker.java.
Öffnen Sie PrefixChecker.java im Editor und fügen Sie den folgenden Code ein:
```
public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";
        String prefix = "Hello";

        boolean startsWithPrefix = text.startsWith(prefix);

        System.out.println("Does the text start with '" + prefix + "'? " + startsWithPrefix);
    }
}
```
In diesem Code:
- Wir deklarieren eine String-Variable text und initialisieren sie mit "Hello, Java!".
- Wir deklarieren eine weitere String-Variable prefix und initialisieren sie mit "Hello".
- Wir rufen die Methode startsWith() auf dem text-String auf und übergeben prefix als Argument. Das Ergebnis (true oder false) wird in der boolean-Variable startsWithPrefix gespeichert.
- Schließlich geben wir das Ergebnis in der Konsole aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren und führen wir dieses Programm aus. Öffnen Sie das Terminal unten in der WebIDE. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie die Java-Datei mit dem Befehl javac:
```
javac PrefixChecker.java
```
Wenn keine Fehler auftreten, erstellt dieser Befehl eine PrefixChecker.class-Datei im Verzeichnis ~/project.
Führen Sie das kompilierte Programm mit dem Befehl java aus:
```
java PrefixChecker
```
Sie sollten die folgende Ausgabe sehen:
```
Does the text start with 'Hello'? true
```

Diese Ausgabe bestätigt, dass der String "Hello, Java!" tatsächlich mit dem Präfix "Hello" beginnt.

Prüfen des Präfixes in verschiedenen Fällen

Im vorherigen Schritt haben Sie erfolgreich die Methode startsWith() verwendet, um auf ein Präfix zu prüfen. Jetzt wollen wir untersuchen, wie startsWith() verschiedene Fälle (Groß- und Kleinbuchstaben) behandelt.

Standardmäßig ist die Methode startsWith() case-sensitive (groß- und kleinschreibungssensitiv). Das bedeutet, dass "Hello" als unterschiedlich von "hello" oder "HELLO" angesehen wird. Ändern wir unsere PrefixChecker.java-Datei, um dies in Aktion zu sehen.

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

Ändern Sie die main-Methode, um Prüfungen mit verschiedenen Fällen einzubeziehen. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefix1 = "Hello";
        String prefix2 = "hello";
        String prefix3 = "HELLO";

        boolean startsWithPrefix1 = text.startsWith(prefix1);
        boolean startsWithPrefix2 = text.startsWith(prefix2);
        boolean startsWithPrefix3 = text.startsWith(prefix3);

        System.out.println("Does the text start with '" + prefix1 + "'? " + startsWithPrefix1);
        System.out.println("Does the text start with '" + prefix2 + "'? " + startsWithPrefix2);
        System.out.println("Does the text start with '" + prefix3 + "'? " + startsWithPrefix3);
    }
}

In diesem aktualisierten Code prüfen wir, ob der text-String mit "Hello", "hello" und "HELLO" beginnt.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie die geänderte Java-Datei:
```
javac PrefixChecker.java
```

Führen Sie das kompilierte Programm aus:

java PrefixChecker

Sie sollten die folgende Ausgabe sehen:

Does the text start with 'Hello'? true
Does the text start with 'hello'? false
Does the text start with 'HELLO'? false

Diese Ausgabe zeigt deutlich, dass startsWith() nur für das Präfix "Hello" (das die Groß- und Kleinschreibung der ursprünglichen Zeichenkette übereinstimmt) true zurückgegeben hat und für "hello" und "HELLO" false. Dies zeigt, dass startsWith() case-sensitive ist.

Wenn Sie eine case-insensitive (groß- und kleinschreibungsunabhängige) Präfixprüfung durchführen müssen, würden Sie normalerweise sowohl die ursprüngliche Zeichenkette als auch das Präfix in dieselbe Groß- oder Kleinschreibung umwandeln, bevor Sie startsWith() verwenden. Beispielsweise könnten Sie text.toLowerCase().startsWith(prefix.toLowerCase()) verwenden. Wir werden dies hier nicht implementieren, aber es ist eine nützliche Technik, die Sie im Hinterkopf behalten sollten.

Prüfen auf Null- und leere Präfixe

In diesem Schritt werden wir untersuchen, wie die Methode startsWith() verhält, wenn das Präfix null oder eine leere Zeichenkette ("") ist. Das Verständnis dieser Randfälle ist wichtig für die Schreibung robuster Code.

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

Ändern Sie die main-Methode, um mit einem null-Präfix und einem leeren Zeichenketten-Präfix zu testen. Ersetzen Sie die vorhandene main-Methode durch den folgenden Code:

public class PrefixChecker {
    public static void main(String[] args) {
        String text = "Hello, Java!";

        String prefixNull = null;
        String prefixEmpty = "";

        // Check with a null prefix
        try {
            boolean startsWithPrefixNull = text.startsWith(prefixNull);
            System.out.println("Does the text start with null? " + startsWithPrefixNull);
        } catch (NullPointerException e) {
            System.out.println("Checking with null prefix resulted in: " + e);
        }

        // Check with an empty prefix
        boolean startsWithPrefixEmpty = text.startsWith(prefixEmpty);
        System.out.println("Does the text start with an empty string? " + startsWithPrefixEmpty);
    }
}

In diesem aktualisierten Code:

Wir deklarieren prefixNull und setzen es auf null.
Wir deklarieren prefixEmpty und setzen es auf eine leere Zeichenkette "".
Wir verwenden einen try-catch-Block, wenn wir mit prefixNull prüfen. Dies liegt daran, dass der Versuch, eine Methode auf einem null-Objekt in Java aufzurufen, zu einer NullPointerException führt. Wir fangen diese Ausnahme auf, um zu sehen, was passiert.
Wir prüfen mit dem leeren Zeichenketten-Präfix prefixEmpty.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Öffnen Sie das Terminal und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.
Kompilieren Sie die geänderte Java-Datei:
```
javac PrefixChecker.java
```

Führen Sie das kompilierte Programm aus:

java PrefixChecker

Sie sollten die folgende Ausgabe sehen:

Checking with null prefix resulted in: java.lang.NullPointerException
Does the text start with an empty string? true

Diese Ausgabe zeigt zwei wichtige Punkte:

Das Übergeben von null als Präfix an startsWith() führt zu einer NullPointerException. Deshalb ist es wichtig, potenzielle null-Werte zu behandeln, bevor Sie Methoden auf ihnen aufrufen.
Das Übergeben einer leeren Zeichenkette ("") als Präfix an startsWith() gibt true zurück. Dies liegt daran, dass jede Zeichenkette als mit einer leeren Zeichenkette beginnend betrachtet werden kann.

Das Verständnis, wie startsWith() null und leere Zeichenketten behandelt, ist wichtig, um Fehler zu vermeiden und korrekte Logik in Ihren Java-Programmen zu schreiben.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Methode startsWith() in Java verwenden, um zu prüfen, ob eine Zeichenkette mit einem bestimmten Präfix beginnt. Sie haben diese Methode angewandt, indem Sie ein einfaches Java-Programm erstellt, kompiliert und ausgeführt haben, um die Ausgabe zu sehen. Diese grundlegende Fähigkeit ist für verschiedene Zeichenkettenmanipulationstasks in der Java-Programmierung unerlässlich.