Wie man prüft, ob ein String in Java nur aus Kleinbuchstaben besteht

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob ein String in Kleinbuchstaben geschrieben ist. Wir werden verschiedene Methoden untersuchen, um dies zu erreichen, beginnend mit dem Vergleichen von Strings unter Ignorieren der Groß- und Kleinschreibung mithilfe von toLowerCase() und equalsIgnoreCase().

Anschließend lernen Sie, wie Sie durch einen String iterieren und Character.isLowerCase() verwenden, um jedes Zeichen einzeln zu prüfen. Abschließend werden wir behandeln, wie Sie nicht-buchstabige Zeichen bei dieser Prüfung behandeln können.

String mit toLowerCase() vergleichen

In diesem Schritt lernen wir, wie man in Java Strings vergleicht, ohne auf die Groß- und Kleinschreibung der Buchstaben zu achten. Dies ist eine häufige Aufgabe, wenn man prüfen möchte, ob zwei Strings gleich sind, unabhängig davon, ob sie Groß- oder Kleinbuchstaben verwenden.

Erstellen wir eine neue Java-Datei, um dies zu üben.

Öffnen Sie die WebIDE, falls sie noch nicht geöffnet ist.
Stellen Sie im Dateiexplorer links sicher, dass Sie sich im Verzeichnis ~/project befinden.
Klicken Sie mit der rechten Maustaste in den leeren Bereich des Dateiexplorers, wählen Sie "Neue Datei" und benennen Sie sie CaseInsensitiveCompare.java.
Öffnen Sie die Datei CaseInsensitiveCompare.java im Editor.

Kopieren Sie den folgenden Code und fügen Sie ihn in den Editor ein:

public class CaseInsensitiveCompare {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "hello";
        String str3 = "World";

        // Comparing strings directly (case-sensitive)
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseSensitive);

        // Comparing strings ignoring case
        boolean areEqualCaseInsensitive = str1.equalsIgnoreCase(str2);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseInsensitive);

        // Comparing str1 and str3 ignoring case
        boolean areEqualStr1Str3 = str1.equalsIgnoreCase(str3);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str3 + "\": " + areEqualStr1Str3);
    }
}

In diesem Code:

Wir deklarieren drei String-Variablen: str1, str2 und str3.
str1.equals(str2) führt einen Groß- und Kleinschreibung-sensitiven Vergleich durch. Es wird false zurückgeben, da "Hello" und "hello" aufgrund des Großbuchstabens 'H' unterschiedlich sind.
str1.equalsIgnoreCase(str2) führt einen Groß- und Kleinschreibung-insensitiven Vergleich durch. Es wird true zurückgeben, da "Hello" und "hello" gleich sind, wenn die Groß- und Kleinschreibung ignoriert wird.
Wir vergleichen auch str1 und str3 unter Ignorieren der Groß- und Kleinschreibung, um zu zeigen, dass unterschiedliche Wörter immer noch als unterschiedlich betrachtet werden.

Speichern Sie die Datei (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 CaseInsensitiveCompare.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe. Eine Datei CaseInsensitiveCompare.class wird im Verzeichnis ~/project erstellt.
Führen Sie das kompilierte Java-Programm mit dem Befehl java aus:
```
java CaseInsensitiveCompare
```
Sie sollten die folgende Ausgabe sehen:
```
Case-sensitive comparison of "Hello" and "hello": false
Case-insensitive comparison of "Hello" and "hello": true
Case-insensitive comparison of "Hello" and "World": false
```
Diese Ausgabe bestätigt, dass equals() Groß- und Kleinschreibung-sensitiv ist, während equalsIgnoreCase() die Groß- und Kleinschreibung ignoriert.

Das Verwenden von equalsIgnoreCase() ist eine bequeme Methode, um Strings zu vergleichen, ohne sich Gedanken darüber machen zu müssen, ob die Buchstaben groß oder klein geschrieben sind.

Character.isLowerCase() in einer Schleife verwenden

Im vorherigen Schritt haben wir gelernt, wie man ganze Strings unter Ignorieren der Groß- und Kleinschreibung vergleicht. Manchmal müssen Sie möglicherweise einzelne Zeichen in einem String untersuchen und prüfen, ob sie Klein- oder Großbuchstaben sind. Java bietet hierfür nützliche Methoden in der Character-Klasse.

In diesem Schritt werden wir die Methode Character.isLowerCase() in einer Schleife verwenden, um die Anzahl der Kleinbuchstaben in einem String zu zählen.

Öffnen Sie die WebIDE, falls sie noch nicht geöffnet ist.
Stellen Sie im Dateiexplorer links sicher, dass Sie sich im Verzeichnis ~/project befinden.
Erstellen Sie eine neue Datei namens CountLowercase.java im Verzeichnis ~/project.
Öffnen Sie die Datei CountLowercase.java im Editor.
Kopieren Sie den folgenden Code und fügen Sie ihn in den Editor ein:
```
public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a lowercase letter
            if (Character.isLowerCase(character)) {
                lowercaseCount++; // Increment the counter if it's lowercase
            }
        }

        System.out.println("The string is: \"" + text + "\"");
        System.out.println("Number of lowercase letters: " + lowercaseCount);
    }
}
```
Lassen Sie uns diesen Code analysieren:
- Wir haben eine String-Variable text, die eine Mischung aus Großbuchstaben, Kleinbuchstaben, Zahlen und Symbolen enthält.
- Wir initialisieren eine Ganzzahlvariable lowercaseCount mit 0. Diese Variable speichert die Anzahl der Kleinbuchstaben.
- Wir verwenden eine for-Schleife, um durch jedes Zeichen des Strings zu iterieren. Die Schleife läuft von Index 0 bis (aber nicht einschließlich) der Länge des Strings.
- text.charAt(i) gibt das Zeichen am aktuellen Index i zurück.
- Character.isLowerCase(character) ist eine Methode, die true zurückgibt, wenn das gegebene character ein Kleinbuchstabe ist, und false sonst.
- Wenn Character.isLowerCase() true zurückgibt, erhöhen wir lowercaseCount.
- Schließlich geben wir den ursprünglichen String und die Gesamtanzahl der Kleinbuchstaben aus.
Speichern Sie die Datei (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:
```
javac CountLowercase.java
```
Wenn die Kompilierung erfolgreich ist, wird eine Datei CountLowercase.class erstellt.
Führen Sie das kompilierte Java-Programm aus:
```
java CountLowercase
```
Sie sollten die folgende Ausgabe sehen:
```
The string is: "Hello World 123!"
Number of lowercase letters: 8
```
Die Ausgabe zeigt, dass es 8 Kleinbuchstaben im String "Hello World 123!" gibt ('e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd').

Das Verwenden von Character.isLowerCase() in einer Schleife ermöglicht es Ihnen, eine zeichenweise Analyse eines Strings durchzuführen, was für verschiedene Textverarbeitungstasks nützlich ist.

Nicht-Buchstaben-Zeichen ignorieren

Im vorherigen Schritt haben wir die Kleinbuchstaben gezählt. Allerdings können Strings verschiedene Zeichen wie Zahlen, Leerzeichen und Symbole enthalten. Beim Vergleichen von Strings oder der Analyse ihres Inhalts möchten Sie diese Nicht-Buchstaben-Zeichen oft ignorieren.

In diesem Schritt werden wir unser Programm so ändern, dass es nur Buchstabenzeichen verarbeitet und alles andere ignoriert. Hierfür verwenden wir die Methode Character.isLetter().

Öffnen Sie die WebIDE, falls sie noch nicht geöffnet ist.
Öffnen Sie die Datei CountLowercase.java, die Sie im vorherigen Schritt erstellt haben.

Ändern Sie den Code, um eine Überprüfung hinzuzufügen, ob ein Zeichen ein Buchstabe ist, bevor Sie prüfen, ob es ein Kleinbuchstabe ist. Ersetzen Sie den vorhandenen Code durch den folgenden:

public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;
        StringBuilder lettersOnly = new StringBuilder(); // To store only letter characters

        // Loop through each character in the string
        for (int i = 0; i < text.length(); i++) {
            char character = text.charAt(i); // Get the character at the current index

            // Check if the character is a letter
            if (Character.isLetter(character)) {
                lettersOnly.append(character); // Add the letter to our new string

                // Check if the letter is lowercase
                if (Character.isLowerCase(character)) {
                    lowercaseCount++; // Increment the counter if it's lowercase
                }
            }
        }

        System.out.println("The original string is: \"" + text + "\"");
        System.out.println("Letters only string: \"" + lettersOnly.toString() + "\"");
        System.out.println("Number of lowercase letters (ignoring non-letters): " + lowercaseCount);
    }
}

Hier ist, was wir hinzugefügt und geändert haben:

Wir haben einen StringBuilder namens lettersOnly eingeführt. StringBuilder wird verwendet, um Strings effizient zu erstellen, insbesondere wenn Sie in einer Schleife Zeichen hinzufügen.
Innerhalb der Schleife haben wir eine if (Character.isLetter(character))-Bedingung hinzugefügt. Diese prüft, ob das aktuelle character ein Buchstabe ist (entweder Groß- oder Kleinbuchstabe).
Wenn das Zeichen ein Buchstabe ist, fügen wir es mit lettersOnly.append(character) dem lettersOnly-StringBuilder hinzu.
Die Überprüfung Character.isLowerCase(character) ist jetzt in die Character.isLetter()-Überprüfung verschachtelt, um sicherzustellen, dass wir nur Kleinbuchstaben unter den Zeichen zählen, die tatsächlich Buchstaben sind.
Schließlich geben wir den ursprünglichen String, den String, der nur Buchstaben enthält, und die Anzahl der Kleinbuchstaben unter diesen Buchstaben aus.

Speichern Sie die Datei (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 geänderte Java-Programm:
```
javac CountLowercase.java
```
Stellen Sie sicher, dass keine Kompilierungsfehler auftreten.
Führen Sie das kompilierte Java-Programm aus:
```
java CountLowercase
```
Sie sollten die folgende Ausgabe sehen:
```
The original string is: "Hello World 123!"
Letters only string: "HelloWorld"
Number of lowercase letters (ignoring non-letters): 8
```
Beachten Sie, dass der "Letters only string" jetzt nur "HelloWorld" enthält und die Anzahl der Kleinbuchstaben immer noch 8 ist, da wir nur Kleinbuchstaben unter den tatsächlichen Buchstaben zählen.

Das Verwenden von Character.isLetter() ist sehr nützlich, wenn Sie nicht-alphabetische Zeichen aus einem String filtern müssen, bevor Sie ihn weiter verarbeiten.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob ein String nur aus Kleinbuchstaben besteht. Wir haben zwei Hauptmethoden untersucht. Zunächst haben wir Strings mit equalsIgnoreCase() verglichen, um eine Groß- und Kleinschreibung ignorierende Vergleichsmethode anzuwenden. Dies hat gezeigt, wie man prüft, ob zwei Strings gleich sind, unabhängig von der Groß- oder Kleinschreibung der Buchstaben.

Zweitens, obwohl die vollständigen Details nicht angegeben wurden, deuten die Schritte darauf hin, dass wir lernen würden, wie man mithilfe einer Schleife durch einen String iteriert und Character.isLowerCase() verwendet, um zu prüfen, ob einzelne Zeichen Kleinbuchstaben sind. Dabei wurde auch berücksichtigt, wie man Nicht-Buchstaben-Zeichen während dieses Prozesses ignoriert.