Java-Programmierung | Zeichenumwandlung | Kleinbuchstaben

Einführung

In der Java-Programmierung wird die Methode toLowerCase(char ch) verwendet, um das angegebene Zeichen-Argument in Kleinbuchstaben umzuwandeln. Diese Methode ist Teil der Character-Klasse in Java und nutzt die Fallzuordnungsinformationen, die von der Unicode-Daten-Datei bereitgestellt werden. Diese Funktionalität ist besonders nützlich, wenn Text verarbeitet wird, der eine Fall-Normalisierung erfordert.

In diesem Lab (Labor) werden Sie lernen, wie Sie die Methode toLowerCase(char ch) in Java-Programmen verwenden. Sie werden eine einfache Anwendung erstellen, die Zeichen in Kleinbuchstaben umwandelt, und diese mit Benutzer-Eingabe- und Fehlerbehandlungsfunktionen erweitern.

Erstellen Sie Ihr erstes Zeichenumwandlungsprogramm

In diesem Schritt werden Sie ein Java-Programm erstellen, das zeigt, wie man ein Zeichen in Kleinbuchstaben umwandelt, indem man die Methode toLowerCase(char ch) aus der Character-Klasse von Java verwendet.

Grundlagen der Zeichen-Größenumwandlung

In Java werden Zeichen durch den primitiven Datentyp char repräsentiert. Die Character-Klasse bietet verschiedene Methoden, um Zeichen zu manipulieren und mit ihnen zu arbeiten, einschließlich der Möglichkeit, zwischen Groß- und Kleinbuchstaben zu konvertieren.

Die Methode toLowerCase(char ch) nimmt ein Zeichen als Eingabe und:

Gibt die Kleinbuchstaben-Version des Zeichens zurück, wenn es ein Großbuchstabe war
Gibt das gleiche Zeichen zurück, wenn es bereits ein Kleinbuchstabe war oder kein Buchstabe ist

Erstellen der Java-Datei

Zunächst erstellen wir eine neue Java-Datei im Projektverzeichnis:

Öffnen Sie das WebIDE-Editorfenster.
Navigieren Sie zum Dateimenü und klicken Sie auf "Neue Datei".
Benennen Sie die Datei CharacterToLowerCase.java und speichern Sie sie im Verzeichnis /home/labex/project.

Alternativ können Sie auch das Terminal verwenden, um die Datei zu erstellen:

cd ~/project
touch CharacterToLowerCase.java

Schreiben Ihres ersten Programms

Jetzt schreiben wir den Code in der Datei CharacterToLowerCase.java:

Öffnen Sie die Datei im WebIDE-Editor.
Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein:

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create character variables with different cases
        char upperCaseChar = 'A';
        char lowerCaseChar = 'b';
        char nonLetterChar = '5';

        // Convert each character to lowercase
        char result1 = Character.toLowerCase(upperCaseChar);
        char result2 = Character.toLowerCase(lowerCaseChar);
        char result3 = Character.toLowerCase(nonLetterChar);

        // Print the original and lowercase characters
        System.out.println("Original uppercase character: " + upperCaseChar);
        System.out.println("After toLowerCase(): " + result1);
        System.out.println();

        System.out.println("Original lowercase character: " + lowerCaseChar);
        System.out.println("After toLowerCase(): " + result2);
        System.out.println();

        System.out.println("Original non-letter character: " + nonLetterChar);
        System.out.println("After toLowerCase(): " + result3);
    }
}

Dieses Programm demonstriert die Methode toLowerCase(char ch) mit drei verschiedenen Zeichentypen:

Einem Großbuchstaben ('A')
Einem Kleinbuchstaben ('b')
Einem Nicht-Buchstaben-Zeichen ('5')

Kompilieren und Ausführen des Programms

Jetzt kompilieren und führen wir das Java-Programm aus:

Öffnen Sie das Terminal im WebIDE.
Navigieren Sie zum Projektverzeichnis, wenn Sie nicht bereits dort sind:
```
cd ~/project
```
Kompilieren Sie die Java-Datei:
```
javac CharacterToLowerCase.java
```
Führen Sie das kompilierte Programm aus:
```
java CharacterToLowerCase
```

Sie sollten die folgende Ausgabe sehen:

Original uppercase character: A
After toLowerCase(): a

Original lowercase character: b
After toLowerCase(): b

Original non-letter character: 5
After toLowerCase(): 5

Wie Sie sehen können, wurde der Großbuchstabe 'A' in den Kleinbuchstaben 'a' umgewandelt, während der bereits kleine Buchstabe 'b' und das Nicht-Buchstaben-Zeichen '5' unverändert blieben.

Verbessern des Programms mit Benutzereingaben

In diesem Schritt werden Sie Ihr Programm verbessern, um Benutzer-Eingaben zu akzeptieren. Anstatt vordefinierte Zeichen zu verwenden, wird das Programm den Benutzer auffordern, ein Zeichen einzugeben und es dann in Kleinbuchstaben umzuwandeln.

Grundlagen der Scanner-Klasse

Um Benutzer-Eingaben in Java zu akzeptieren, verwenden wir die Scanner-Klasse aus dem java.util-Paket. Die Scanner-Klasse bietet Methoden, um verschiedene Arten von Eingabedaten (wie Ganzzahlen, Gleitkommazahlen, Strings usw.) aus verschiedenen Quellen, einschließlich der Standard-Eingabe (Tastatur), zu lesen.

So verwenden wir die Scanner-Klasse:

Importieren Sie die Klasse mit import java.util.Scanner;
Erstellen Sie ein Scanner-Objekt mit Scanner scanner = new Scanner(System.in);
Verwenden Sie Methoden wie next(), nextInt() usw., um Eingaben zu lesen

Modifizieren des Programms

Lassen Sie uns unser Programm so ändern, dass es Benutzer-Eingaben akzeptiert:

Öffnen Sie die Datei CharacterToLowerCase.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.Scanner;

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a character
        System.out.print("Enter a character: ");

        // Read the first character of the input
        String input = scanner.next();
        char userChar = input.charAt(0);

        // Convert the character to lowercase
        char lowerCaseChar = Character.toLowerCase(userChar);

        // Print the original and lowercase characters
        System.out.println("Original character: " + userChar);
        System.out.println("Lowercase character: " + lowerCaseChar);

        // Close the scanner
        scanner.close();
    }
}

Die wichtigsten Änderungen in diesem Code sind:

Wir importieren die Scanner-Klasse.
Wir erstellen ein Scanner-Objekt, um Eingaben von der Konsole zu lesen.
Wir fordern den Benutzer auf, ein Zeichen einzugeben.
Wir lesen die Eingabe als String und extrahieren dann das erste Zeichen.
Wir wandeln das Zeichen in Kleinbuchstaben um und zeigen sowohl das ursprüngliche als auch das Kleinbuchstaben-Zeichen an.
Wir schließen den Scanner, um Ressourcen freizugeben.

Kompilieren und Ausführen des modifizierten Programms

Lassen Sie uns das modifizierte Programm kompilieren und ausführen:

Öffnen Sie das Terminal im WebIDE.
Navigieren Sie zum Projektverzeichnis, wenn Sie nicht bereits dort sind:
```
cd ~/project
```
Kompilieren Sie die Java-Datei:
```
javac CharacterToLowerCase.java
```
Führen Sie das kompilierte Programm aus:
```
java CharacterToLowerCase
```
Wenn Sie dazu aufgefordert werden, geben Sie ein Zeichen ein (z. B. 'Z') und drücken Sie die Eingabetaste.

Sie sollten eine Ausgabe ähnlich der folgenden sehen (angenommen, Sie haben 'Z' eingegeben):

Enter a character: Z
Original character: Z
Lowercase character: z

Versuchen Sie, verschiedene Zeichen einzugeben, um zu sehen, wie das Programm mit Kleinbuchstaben, Großbuchstaben und Nicht-Buchstaben-Zeichen umgeht.

Fehler und ungültige Eingaben verarbeiten

Im vorherigen Schritt hat unser Programm gut funktioniert, wenn der Benutzer ein gültiges Zeichen eingegeben hat. Wenn der Benutzer jedoch eine leere Zeichenkette eingegeben hat oder es bei der Eingabeauslesung andere Probleme gab, könnte das Programm mit einer Ausnahme abstürzen. In diesem Schritt werden wir unser Programm verbessern, um potenzielle Fehler und ungültige Eingaben zu behandeln.

Grundlagen der Ausnahmebehandlung in Java

Die Ausnahmebehandlung in Java erfolgt mit try-catch-Blöcken:

Der Code, der eine Ausnahme auslösen könnte, wird in den try-Block platziert.
Der Code zur Behandlung der Ausnahme wird in den catch-Block platziert.
Sie können bestimmte Ausnahmen abfangen, indem Sie den Ausnahmetyp angeben.

Modifizieren des Programms zur Fehlerbehandlung

Lassen Sie uns unser Programm so ändern, dass es potenzielle Fehler behandelt:

Öffnen Sie die Datei CharacterToLowerCase.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch den folgenden:

import java.util.Scanner;

public class CharacterToLowerCase {
    public static void main(String[] args) {
        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Continue until valid input is received
        boolean validInput = false;

        while (!validInput) {
            try {
                // Prompt the user to enter a character
                System.out.print("Enter a character: ");

                // Read the first character of the input
                String input = scanner.next();
                if (input.isEmpty()) {
                    System.out.println("Error: Empty input. Please enter a character.");
                    continue;
                }

                char userChar = input.charAt(0);

                // Convert the character to lowercase
                char lowerCaseChar = Character.toLowerCase(userChar);

                // Print the original and lowercase characters
                System.out.println("Original character: " + userChar);
                System.out.println("Lowercase character: " + lowerCaseChar);

                // If a character is already lowercase or is not a letter, explain the result
                if (userChar == lowerCaseChar) {
                    if (Character.isLetter(userChar)) {
                        System.out.println("Note: The character was already lowercase.");
                    } else {
                        System.out.println("Note: The character is not a letter, so it remains unchanged.");
                    }
                }

                validInput = true;  // Exit the loop

            } catch (Exception e) {
                // Handle any exceptions that might occur
                System.out.println("Error: Invalid input. Please try again.");
                scanner.nextLine();  // Clear the input buffer
            }
        }

        // Close the scanner
        scanner.close();
    }
}

Die wichtigsten Änderungen in diesem Code sind:

Wir haben eine Schleife hinzugefügt, um die Eingabeaufforderung so lange wiederholen, bis eine gültige Eingabe erfolgt.
Wir haben einen try-catch-Block hinzugefügt, um potenzielle Ausnahmen zu behandeln.
Wir prüfen, ob die Eingabe leer ist.
Wir haben zusätzliche Informationen hinzugefügt, warum bestimmte Zeichen unverändert bleiben.
Wir leeren den Eingabepuffer im Falle einer ungültigen Eingabe.

Kompilieren und Ausführen des finalen Programms

Lassen Sie uns das verbesserte Programm kompilieren und ausführen:

Öffnen Sie das Terminal im WebIDE.
Navigieren Sie zum Projektverzeichnis, wenn Sie nicht bereits dort sind:
```
cd ~/project
```
Kompilieren Sie die Java-Datei:
```
javac CharacterToLowerCase.java
```
Führen Sie das kompilierte Programm aus:
```
java CharacterToLowerCase
```

Lassen Sie uns verschiedene Szenarien testen:

Geben Sie einen Großbuchstaben ein (z. B. 'A'):

Enter a character: A
Original character: A
Lowercase character: a

Geben Sie einen Kleinbuchstaben ein (z. B. 'a'):

Enter a character: a
Original character: a
Lowercase character: a
Note: The character was already lowercase.

Geben Sie ein Nicht-Buchstaben-Zeichen ein (z. B. '5'):

Enter a character: 5
Original character: 5
Lowercase character: 5
Note: The character is not a letter, so it remains unchanged.

Versuchen Sie, ohne ein Zeichen einzugeben, die Eingabetaste zu drücken oder geben Sie eine ungültige Eingabe ein:
```
Enter a character:
Error: Invalid input. Please try again.
Enter a character:
```

Das Programm behandelt jetzt verschiedene Eingabeszenarien elegant und gibt dem Benutzer hilfreiche Rückmeldungen.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie die Methode toLowerCase(char ch) in Java verwenden, um Zeichen in Kleinbuchstaben umzuwandeln. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

Sie haben ein einfaches Java-Programm erstellt, das die Umwandlung von Zeichen zwischen Groß- und Kleinbuchstaben mit der Methode toLowerCase(char ch) demonstriert.
Sie haben das Programm verbessert, um Benutzer-Eingaben mit der Scanner-Klasse zu akzeptieren, sodass Benutzer ihre eigenen Zeichen zur Umwandlung eingeben können.
Sie haben die Robustheit des Programms verbessert, indem Sie die Fehlerbehandlung mit try-catch-Blöcken hinzugefügt haben, um ungültige Eingaben elegant zu behandeln.
Sie haben informative Nachrichten hinzugefügt, um zu erklären, warum bestimmte Zeichen unverändert bleiben, wenn sie an die Methode toLowerCase(char ch) übergeben werden.

Diese Fähigkeiten sind grundlegend für die Java-Programmierung und können in vielen realen Szenarien angewendet werden, wie beispielsweise:

Textverarbeitung und -normalisierung
Formularvalidierung
Suchfunktionen (groß- und kleinschreibungsunabhängige Suche)
Datenbereinigung und -vorbereitung

Wenn Sie Ihre Java-Lernreise fortsetzen, denken Sie daran, dass die Character-Klasse viele andere nützliche Methoden für die Arbeit mit Zeichen bietet, wie isLetter(), isDigit(), isUpperCase(), isLowerCase() und viele mehr.

Zeichen in Java in Kleinbuchstaben umwandeln