Wie man prüft, ob ein String in Java nur aus Großbuchstaben besteht

Einführung

In diesem Lab werden Sie lernen, wie Sie in Java prüfen können, ob ein String in Großbuchstaben geschrieben ist. Wir werden verschiedene Methoden untersuchen, um dies zu erreichen, beginnend mit dem Vergleich des ursprünglichen Strings mit seiner Großbuchstaben-Version mithilfe der Methode toUpperCase().

Danach werden Sie lernen, wie Sie durch einen String iterieren und die Methode Character.isUpperCase() verwenden, um den Schreibweise (Groß- oder Kleinbuchstabe) einzelner Zeichen zu prüfen. Abschließend werden wir besprechen, wie Sie nicht-buchstabige Zeichen innerhalb des Strings behandeln können, wenn Sie diese Prüfungen durchführen.

String mit toUpperCase() vergleichen

In diesem Schritt werden Sie lernen, wie Sie Strings in Java vergleichen können, insbesondere wie Sie größenunabhängige Vergleiche durchführen. Dies ist eine häufige Aufgabe in der Programmierung, beispielsweise wenn Sie prüfen müssen, ob ein Benutzer "yes", "Yes" oder "YES" eingegeben hat.

Zunächst erstellen wir eine neue Java-Datei namens StringCompare.java in Ihrem ~/project-Verzeichnis. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer links klicken und "Neue Datei" auswählen, und dann StringCompare.java eingeben.

Öffnen Sie jetzt die StringCompare.java-Datei im Editor und fügen Sie den folgenden Code hinzu:

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

        // Case-sensitive comparison
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison: " + areEqualCaseSensitive);

        // Case-insensitive comparison using toUpperCase()
        boolean areEqualCaseInsensitive = str1.toUpperCase().equals(str2.toUpperCase());
        System.out.println("Case-insensitive comparison using toUpperCase(): " + areEqualCaseInsensitive);
    }
}

Lassen Sie uns diesen Code analysieren:

• Wir deklarieren zwei String-Variablen, str1 und str2, mit unterschiedlicher Groß- und Kleinschreibung.
• str1.equals(str2) führt einen größenabhängigen Vergleich durch. Es gibt nur dann true zurück, wenn die Strings exakt gleich sind, einschließlich der Groß- und Kleinschreibung der Buchstaben.
• str1.toUpperCase() wandelt str1 in alle Großbuchstaben um ("HELLO").
• str2.toUpperCase() wandelt str2 in alle Großbuchstaben um ("HELLO").
• Anschließend verwenden wir .equals(), um die Großbuchstaben-Versionen der Strings zu vergleichen, was effektiv einen größenunabhängigen Vergleich darstellt.

Speichern Sie die Datei, indem Sie Strg + S drücken (oder Cmd + S auf einem Mac).

Lassen Sie uns jetzt dieses Programm im Terminal kompilieren und ausführen. Stellen Sie sicher, dass Sie sich im ~/project-Verzeichnis befinden.

Kompilieren Sie den Code:

javac StringCompare.java

Wenn keine Fehler auftreten, wird eine StringCompare.class-Datei erstellt.

Führen Sie jetzt den kompilierten Code aus:

java StringCompare

Sie sollten die folgende Ausgabe sehen:

Case-sensitive comparison: false
Case-insensitive comparison using toUpperCase(): true

Diese Ausgabe zeigt, dass der größenabhängige Vergleich (equals()) false zurückgibt, da "Hello" und "hello" aufgrund der Groß- und Kleinschreibung unterschiedlich sind, während der größenunabhängige Vergleich mit toUpperCase() true zurückgibt, da beide Strings bei der Umwandlung in Großbuchstaben "HELLO" werden.

Das Verwenden von toUpperCase() (oder toLowerCase()) vor dem Vergleich von Strings ist eine gängige Methode, um größenunabhängige Vergleiche in Java durchzuführen.

Character.isUpperCase() in einer Schleife verwenden

Im vorherigen Schritt haben wir gelernt, wie man ganze Strings größenunabhängig vergleicht. Jetzt wollen wir untersuchen, wie man einzelne Zeichen in einem String prüfen kann und feststellen kann, ob sie Großbuchstaben sind. Dies ist nützlich, wenn Sie die Struktur eines Strings analysieren müssen, beispielsweise wenn Sie die Anzahl der Großbuchstaben zählen oder das Eingabeformat validieren möchten.

Java bietet die Character-Klasse, die nützliche Methoden für die Arbeit mit einzelnen Zeichen enthält. Eine solche Methode ist isUpperCase(), die prüft, ob ein gegebenes Zeichen ein Großbuchstabe ist.

Lassen Sie uns unsere StringCompare.java-Datei ändern, um dies zu demonstrieren. Öffnen Sie ~/project/StringCompare.java im Editor und ersetzen Sie den Inhalt durch den folgenden Code:

public class StringCompare {
    public static void main(String[] args) {
        String text = "Hello World";
        int uppercaseCount = 0;

        System.out.println("Analyzing the string: \"" + text + "\"");

        // 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 uppercase
            if (Character.isUpperCase(character)) {
                System.out.println("Found an uppercase character: " + character + " at index " + i);
                uppercaseCount++; // Increment the counter
            }
        }

        System.out.println("Total uppercase characters found: " + uppercaseCount);
    }
}

Lassen Sie uns die neuen Teile dieses Codes verstehen:

• Wir deklarieren eine String-Variable text und eine Ganzzahlvariable uppercaseCount, die auf 0 initialisiert wird.
• Wir verwenden eine for-Schleife, um durch jedes Zeichen des text-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 im String zurück.
• Character.isUpperCase(character) prüft, ob das Zeichen ein Großbuchstabe ist. Diese Methode gibt true zurück, wenn das Zeichen ein Großbuchstabe ist, und false sonst.
• Wenn isUpperCase() true zurückgibt, geben wir eine Nachricht aus, die das Großbuchstabenzeichen und seinen Index angibt, und wir erhöhen uppercaseCount.

Speichern Sie die Datei (Strg + S).

Jetzt kompilieren und führen Sie das geänderte Programm im Terminal aus dem ~/project-Verzeichnis aus:

Kompilieren:

javac StringCompare.java

Ausführen:

java StringCompare

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Analyzing the string: "Hello World"
Found an uppercase character: H at index 0
Found an uppercase character: W at index 6
Total uppercase characters found: 2

Diese Ausgabe zeigt, dass unser Programm die Großbuchstaben 'H' und 'W' im String korrekt identifiziert und gezählt hat.

Das Verwenden von Character.isUpperCase() in einer Schleife ist eine leistungsstarke Technik zur zeichenweisen Analyse von Strings. Im nächsten Schritt werden wir betrachten, wie man Zeichen behandeln kann, die keine Buchstaben sind.

Nicht-Buchstaben-Zeichen behandeln

Im vorherigen Schritt haben wir Character.isUpperCase() verwendet, um Großbuchstaben zu identifizieren. Allerdings können Strings mehr als nur Buchstaben enthalten – sie können auch Zahlen, Symbole, Leerzeichen und Satzzeichen beinhalten. Bei der Analyse von Strings ist es oft notwendig, zwischen verschiedenen Zeichentypen zu unterscheiden.

Die Character-Klasse bietet andere nützliche Methoden für diesen Zweck, wie beispielsweise:

• Character.isLetter(char ch): Prüft, ob ein Zeichen ein Buchstabe ist.
• Character.isDigit(char ch): Prüft, ob ein Zeichen eine Ziffer (0 - 9) ist.
• Character.isWhitespace(char ch): Prüft, ob ein Zeichen ein Leerzeichen (wie Leerzeichen, Tabulator, Zeilenumbruch) ist.

Lassen Sie uns erneut unsere StringCompare.java-Datei ändern, um zu zeigen, wie man Nicht-Buchstaben-Zeichen behandelt und verschiedene Zeichentypen in einem String zählt. Öffnen Sie ~/project/StringCompare.java im Editor und ersetzen Sie den Inhalt durch den folgenden Code:

public class StringCompare {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int letterCount = 0;
        int digitCount = 0;
        int whitespaceCount = 0;
        int otherCount = 0;

        System.out.println("Analyzing the string: \"" + text + "\"");

        // 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 the type of the character
            if (Character.isLetter(character)) {
                letterCount++;
            } else if (Character.isDigit(character)) {
                digitCount++;
            } else if (Character.isWhitespace(character)) {
                whitespaceCount++;
            } else {
                otherCount++; // Characters that are not letters, digits, or whitespace
            }
        }

        System.out.println("Total characters: " + text.length());
        System.out.println("Letter count: " + letterCount);
        System.out.println("Digit count: " + digitCount);
        System.out.println("Whitespace count: " + whitespaceCount);
        System.out.println("Other character count: " + otherCount);
    }
}

In diesem aktualisierten Code:

• Wir initialisieren Zähler für Buchstaben, Ziffern, Leerzeichen und andere Zeichen.
• Innerhalb der Schleife verwenden wir if-else if-else-Anweisungen, um den Typ jedes Zeichens mit Character.isLetter(), Character.isDigit() und Character.isWhitespace() zu prüfen.
• Wir erhöhen den entsprechenden Zähler basierend auf dem Zeichentyp.
• Schließlich geben wir die Zählungen für jeden Zeichentyp aus.

Speichern Sie die Datei (Strg + S).

Jetzt kompilieren und führen Sie das Programm im Terminal aus dem ~/project-Verzeichnis aus:

Kompilieren:

javac StringCompare.java

Ausführen:

java StringCompare

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Analyzing the string: "Hello World 123!"
Total characters: 16
Letter count: 10
Digit count: 3
Whitespace count: 2
Other character count: 1

Diese Ausgabe identifiziert und zählt die verschiedenen Zeichentypen im String "Hello World 123!" korrekt. Die Buchstaben sind 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' (insgesamt 10). Die Ziffern sind '1', '2', '3' (insgesamt 3). Die Leerzeichen sind das Leerzeichen zwischen "Hello" und "World" sowie das Leerzeichen zwischen "World" und "123" (insgesamt 2). Das andere Zeichen ist '!' (insgesamt 1). Die Gesamtzahl ist 10 + 3 + 2 + 1 = 16, was mit der Länge des Strings übereinstimmt.

Durch die Verwendung von Methoden wie Character.isLetter(), Character.isDigit() und Character.isWhitespace() können Sie robusteren Code schreiben, der verschiedene Zeichentypen in einem String verarbeiten kann. Dies ist für Aufgaben wie die Datenvalidierung, die Eingabeanalyse oder die Textanalyse von entscheidender Bedeutung.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob ein String nur aus Großbuchstaben besteht. Wir haben zwei Hauptmethoden untersucht. Zunächst haben wir einen String mit seiner Großschreibweise mithilfe der toUpperCase()-Methode und der equals()-Methode verglichen, um einen größenunabhängigen Vergleich durchzuführen. Diese Methode ist nützlich, um zu prüfen, ob zwei Strings gleich sind, unabhängig von ihrer Schreibweise.

Zweitens haben wir gelernt, wie man durch einen String iteriert und die Character.isUpperCase()-Methode in einer Schleife verwendet, um zu prüfen, ob jedes Zeichen ein Großbuchstabe ist. Wir haben auch betrachtet, wie man Nicht-Buchstaben-Zeichen während dieses Prozesses behandelt, um sicherzustellen, dass unsere Prüfung robust ist. Diese Techniken bieten verschiedene Ansätze zur Bestimmung des Großschreibungsstatus eines Strings basierend auf den spezifischen Anforderungen der Aufgabe.