Programmation Java | Conversion de caractères | Minuscules

Introduction

En programmation Java, la méthode toLowerCase(char ch) est utilisée pour convertir le caractère donné en minuscules. Cette méthode fait partie de la classe Character en Java et utilise les informations de mappage de cas fournies par le fichier de données Unicode. Cette fonctionnalité est particulièrement utile lors du traitement de texte qui nécessite une normalisation de la casse.

Dans ce lab (atelier) LabEx, vous apprendrez à utiliser la méthode toLowerCase(char ch) dans des programmes Java. Vous créerez une application simple qui convertit des caractères en minuscules et l'améliorerez en ajoutant la prise en charge de l'entrée utilisateur et la gestion des erreurs.

Créez votre premier programme de conversion de caractères

Dans cette étape, vous allez créer un programme Java qui montre comment convertir un caractère en minuscules en utilisant la méthode toLowerCase(char ch) de la classe Character de Java.

Comprendre la conversion de la casse des caractères

En Java, les caractères sont représentés par le type de données primitif char. La classe Character fournit diverses méthodes pour manipuler et travailler avec les caractères, y compris la capacité de convertir entre majuscules et minuscules.

La méthode toLowerCase(char ch) prend un caractère en entrée et :

Renvoie la version en minuscules du caractère s'il était en majuscules
Renvoie le même caractère s'il était déjà en minuscules ou s'il n'est pas une lettre

Création du fichier Java

Tout d'abord, créons un nouveau fichier Java dans le répertoire du projet :

Ouvrez la fenêtre de l'éditeur WebIDE
Accédez au menu Fichier et cliquez sur "Nouveau fichier"
Nommez le fichier CharacterToLowerCase.java et enregistrez-le dans le répertoire /home/labex/project

Alternativement, vous pouvez utiliser le terminal pour créer le fichier :

cd ~/project
touch CharacterToLowerCase.java

Écriture de votre premier programme

Maintenant, écrivons le code dans le fichier CharacterToLowerCase.java :

Ouvrez le fichier dans l'éditeur WebIDE
Copiez et collez le code suivant dans le fichier :

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);
    }
}

Ce programme démontre la méthode toLowerCase(char ch) avec trois types différents de caractères :

Une lettre majuscule ('A')
Une lettre minuscule ('b')
Un caractère non-lettre ('5')

Compilation et exécution du programme

Maintenant, compilons et exécutons le programme Java :

Ouvrez le terminal dans le WebIDE
Accédez au répertoire du projet si vous n'y êtes pas déjà :
```
cd ~/project
```
Compilez le fichier Java :
```
javac CharacterToLowerCase.java
```
Exécutez le programme compilé :
```
java CharacterToLowerCase
```

Vous devriez voir la sortie suivante :

Original uppercase character: A
After toLowerCase(): a

Original lowercase character: b
After toLowerCase(): b

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

Comme vous pouvez le voir, la majuscule 'A' a été convertie en minuscule 'a', tandis que la minuscule 'b' et le caractère non-lettre '5' sont restés inchangés.

Amélioration du programme avec une entrée utilisateur

Dans cette étape, vous allez améliorer votre programme pour qu'il accepte une entrée utilisateur. Au lieu d'utiliser des caractères prédéfinis, le programme demandera à l'utilisateur d'entrer un caractère puis le convertira en minuscules.

Comprendre la classe Scanner

Pour accepter une entrée utilisateur en Java, nous allons utiliser la classe Scanner du package java.util. La classe Scanner fournit des méthodes pour lire différents types de données d'entrée (comme des entiers, des nombres à virgule flottante, des chaînes de caractères, etc.) à partir de diverses sources, y compris l'entrée standard (le clavier).

Voici comment nous allons utiliser la classe Scanner :

Importez la classe avec import java.util.Scanner;
Créez un objet Scanner avec Scanner scanner = new Scanner(System.in);
Utilisez des méthodes comme next(), nextInt(), etc. pour lire l'entrée

Modification du programme

Modifions notre programme pour qu'il accepte une entrée utilisateur :

Ouvrez le fichier CharacterToLowerCase.java dans l'éditeur WebIDE
Remplacez le code existant par le suivant :

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();
    }
}

Les principales modifications dans ce code sont les suivantes :

Nous importons la classe Scanner
Nous créons un objet Scanner pour lire l'entrée depuis la console
Nous demandons à l'utilisateur d'entrer un caractère
Nous lisons l'entrée sous forme de chaîne de caractères puis nous extrayons le premier caractère
Nous convertissons le caractère en minuscules et affichons à la fois le caractère original et le caractère en minuscules
Nous fermons le scanner pour libérer les ressources

Compilation et exécution du programme modifié

Compilons et exécutons le programme modifié :

Ouvrez le terminal dans le WebIDE
Accédez au répertoire du projet si vous n'y êtes pas déjà :
```
cd ~/project
```
Compilez le fichier Java :
```
javac CharacterToLowerCase.java
```
Exécutez le programme compilé :
```
java CharacterToLowerCase
```
Lorsque vous y êtes invité, entrez un caractère (par exemple, 'Z') puis appuyez sur Entrée.

Vous devriez voir une sortie similaire à celle-ci (en supposant que vous avez entré 'Z') :

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

Essayez d'entrer différents caractères pour voir comment le programme se comporte avec des lettres minuscules, des lettres majuscules et des caractères non-lettres.

Gestion des erreurs et des entrées invalides

Dans l'étape précédente, notre programme fonctionnait bien lorsque l'utilisateur entré un caractère valide. Cependant, si l'utilisateur entré une chaîne de caractères vide ou s'il y avait un autre problème lors de la lecture de l'entrée, le programme pouvait planter avec une exception. Dans cette étape, nous allons améliorer notre programme pour gérer les erreurs potentielles et les entrées invalides.

Comprendre la gestion des exceptions en Java

La gestion des exceptions en Java est effectuée à l'aide de blocs try-catch :

Le code susceptible de lancer une exception est placé dans le bloc try
Le code pour gérer l'exception est placé dans le bloc catch
Vous pouvez capturer des exceptions spécifiques en spécifiant le type d'exception

Modification du programme pour gérer les erreurs

Modifions notre programme pour gérer les erreurs potentielles :

Ouvrez le fichier CharacterToLowerCase.java dans l'éditeur WebIDE
Remplacez le code existant par le suivant :

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();
    }
}

Les principales modifications dans ce code sont les suivantes :

Nous avons ajouté une boucle pour continuer à demander une entrée jusqu'à ce qu'une entrée valide soit reçue
Nous avons ajouté un bloc try-catch pour gérer les exceptions potentielles
Nous vérifions si l'entrée est vide
Nous avons ajouté des informations supplémentaires expliquant pourquoi certains caractères restent inchangés
Nous vidons le tampon d'entrée en cas d'entrée invalide

Compilation et exécution du programme final

Compilons et exécutons le programme amélioré :

Ouvrez le terminal dans le WebIDE
Accédez au répertoire du projet si vous n'y êtes pas déjà :
```
cd ~/project
```
Compilez le fichier Java :
```
javac CharacterToLowerCase.java
```
Exécutez le programme compilé :
```
java CharacterToLowerCase
```

Testons différents scénarios :

Entrez une lettre majuscule (par exemple, 'A') :

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

Entrez une lettre minuscule (par exemple, 'a') :

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

Entrez un caractère non-lettre (par exemple, '5') :

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

Essayez d'appuyer sur Entrée sans taper de caractère, ou entrez une entrée invalide :
```
Enter a character:
Error: Invalid input. Please try again.
Enter a character:
```

Le programme gère désormais de manière gracieuse différents scénarios d'entrée, fournissant des commentaires utiles à l'utilisateur.

Résumé

Dans ce laboratoire, vous avez appris à utiliser la méthode toLowerCase(char ch) en Java pour convertir des caractères en minuscules. Voici un récapitulatif de ce que vous avez accompli :

Vous avez créé un programme Java de base qui démontre la conversion de casse de caractères à l'aide de la méthode toLowerCase(char ch).
Vous avez amélioré le programme pour qu'il accepte une entrée utilisateur en utilisant la classe Scanner, permettant aux utilisateurs d'entrer leurs propres caractères pour la conversion.
Vous avez amélioré la robustesse du programme en ajoutant une gestion d'erreurs avec des blocs try-catch pour gérer gracieusement les entrées invalides.
Vous avez ajouté des messages informatifs pour expliquer pourquoi certains caractères restent inchangés lorsqu'ils sont passés à la méthode toLowerCase(char ch).

Ces compétences sont fondamentales en programmation Java et peuvent être appliquées à de nombreux scénarios du monde réel, tels que :

Le traitement et la normalisation de texte
La validation de formulaires
La fonctionnalité de recherche (recherche insensible à la casse)
Le nettoyage et la préparation de données

Au fur et à mesure que vous poursuivrez votre apprentissage de Java, rappelez-vous que la classe Character propose de nombreuses autres méthodes utiles pour travailler avec les caractères, telles que isLetter(), isDigit(), isUpperCase(), isLowerCase(), etc.

Convertir un caractère en minuscules en Java