Comment vérifier si un caractère est en minuscule en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un caractère est en minuscules en Java en utilisant la méthode Character.isLowerCase(). Vous allez pratiquer l'utilisation de cette méthode avec divers caractères, y compris les lettres minuscules, les lettres majuscules, les chiffres et les symboles, pour comprendre son fonctionnement.

Grâce à des exercices pratiques, vous allez créer un simple programme Java pour démontrer l'utilisation de Character.isLowerCase() et observer la sortie booléenne pour différents types de caractères. Ce laboratoire (lab) vous offrira une compréhension pratique de la façon de déterminer la casse d'un caractère en Java.

Utiliser la méthode Character.isLowerCase()

Dans cette étape, vous apprendrez à utiliser la méthode Character.isLowerCase() en Java. Cette méthode fait partie de la classe Character et est utilisée pour déterminer si un caractère donné est une lettre minuscule.

La méthode Character.isLowerCase() prend un seul caractère en argument et renvoie une valeur booléenne : true si le caractère est une lettre minuscule, et false sinon.

Créons un nouveau fichier Java pour pratiquer l'utilisation de cette méthode.

Ouvrez l'Explorateur de fichiers sur le côté gauche de l'IDE Web.
Accédez au répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide du répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier LowerCaseCheck.java.
Ouvrez le fichier LowerCaseCheck.java dans l'éditeur.

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

public class LowerCaseCheck {
    public static void main(String[] args) {
        char char1 = 'a';
        char char2 = 'B';
        char char3 = '5';
        char char4 = '$';

        boolean isLower1 = Character.isLowerCase(char1);
        boolean isLower2 = Character.isLowerCase(char2);
        boolean isLower3 = Character.isLowerCase(char3);
        boolean isLower4 = Character.isLowerCase(char4);

        System.out.println("Is '" + char1 + "' lowercase? " + isLower1);
        System.out.println("Is '" + char2 + "' lowercase? " + isLower2);
        System.out.println("Is '" + char3 + "' lowercase? " + isLower3);
        System.out.println("Is '" + char4 + "' lowercase? " + isLower4);
    }
}

Dans ce code :

Nous déclarons quatre variables de type char, chacune contenant un caractère différent.
Nous utilisons Character.isLowerCase() pour vérifier si chaque caractère est en minuscule et stockons le résultat dans une variable de type boolean.
Nous affichons ensuite les résultats dans la console.

Enregistrez le fichier en appuyant sur Ctrl + S (ou Cmd + S sur Mac).

Maintenant, compilons et exécutons ce programme pour voir la sortie.

Ouvrez le Terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.
Compilez le fichier Java en utilisant la commande javac :
```
javac LowerCaseCheck.java
```
S'il n'y a pas d'erreurs, cette commande créera un fichier LowerCaseCheck.class dans le répertoire ~/project.
Exécutez le programme Java compilé en utilisant la commande java :
```
java LowerCaseCheck
```
Vous devriez voir une sortie similaire à celle-ci :
```
Is 'a' lowercase? true
Is 'B' lowercase? false
Is '5' lowercase? false
Is '$' lowercase? false
```

Cette sortie montre que Character.isLowerCase() a correctement identifié 'a' comme étant en minuscule et les autres caractères comme n'étant pas en minuscule.

Tester avec divers caractères

Dans l'étape précédente, vous avez appris à utiliser Character.isLowerCase() avec quelques exemples. Maintenant, testons cette méthode avec une plus large gamme de caractères pour voir son comportement. Comprendre le fonctionnement d'une méthode avec différents types d'entrées est essentiel en programmation.

Nous allons modifier le fichier LowerCaseCheck.java que nous avons créé à la dernière étape pour inclure plus de cas de test.

Ouvrez le fichier LowerCaseCheck.java dans l'éditeur de l'IDE Web. Il devrait se trouver dans le répertoire ~/project.

Modifiez la méthode main pour inclure plus de caractères à tester. Remplacez le code existant à l'intérieur de la méthode main par le suivant :

public static void main(String[] args) {
    char char1 = 'z'; // Lettre minuscule
    char char2 = 'A'; // Lettre majuscule
    char char3 = '9'; // Chiffre
    char char4 = '!'; // Symbole
    char char5 = 'é'; // Lettre minuscule avec accent (Unicode)
    char char6 = 'Ü'; // Lettre majuscule avec tréma (Unicode)
    char char7 = ' '; // Espace

    System.out.println("Is '" + char1 + "' lowercase? " + Character.isLowerCase(char1));
    System.out.println("Is '" + char2 + "' lowercase? " + Character.isLowerCase(char2));
    System.out.println("Is '" + char3 + "' lowercase? " + Character.isLowerCase(char3));
    System.out.println("Is '" + char4 + "' lowercase? " + Character.isLowerCase(char4));
    System.out.println("Is '" + char5 + "' lowercase? " + Character.isLowerCase(char5));
    System.out.println("Is '" + char6 + "' lowercase? " + Character.isLowerCase(char6));
    System.out.println("Is '" + char7 + "' lowercase? " + Character.isLowerCase(char7));
}

Nous avons ajouté plus de caractères, notamment une lettre minuscule à la fin de l'alphabet ('z'), une lettre majuscule au début ('A'), un chiffre ('9'), un symbole ('!'), et quelques caractères Unicode avec accents et trémas ('é' et 'Ü'). Nous avons également inclus un caractère espace (' ').

Enregistrez le fichier LowerCaseCheck.java modifié (Ctrl + S ou Cmd + S).

Maintenant, compilons et exécutons le programme mis à jour.

Ouvrez le Terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java modifié :
```
javac LowerCaseCheck.java
```
Encore une fois, si la compilation réussit, vous ne verrez aucune sortie.
Exécutez le programme Java compilé :
```
java LowerCaseCheck
```
Observez la sortie. Elle devrait ressembler à ceci :
```
Is 'z' lowercase? true
Is 'A' lowercase? false
Is '9' lowercase? false
Is '!' lowercase? false
Is 'é' lowercase? true
Is 'Ü' lowercase? false
Is ' ' lowercase? false
```
Remarquez que Character.isLowerCase() identifie correctement 'z' et 'é' comme des lettres minuscules, tandis que 'A', '9', '!', 'Ü' et ' ' ne sont pas considérés comme des lettres minuscules par cette méthode. Cela démontre que la méthode fonctionne pour une variété de caractères, y compris certaines lettres non ASCII.

Gérer les caractères non alphabétiques

Dans les étapes précédentes, vous avez vu comment Character.isLowerCase() fonctionne avec les lettres minuscules et majuscules, ainsi qu'avec certains caractères non alphabétiques tels que les chiffres, les symboles et les espaces. Il est important de se rappeler que Character.isLowerCase() est spécifiquement conçu pour vérifier si un caractère est une lettre minuscule. Il renverra false pour tout caractère qui n'est pas considéré comme une lettre selon la norme Unicode, qu'il ait ou non une forme "minuscule" (comme un chiffre minuscule, qui n'existe pas).

Créons un programme légèrement différent qui se concentre sur la vérification de divers caractères non alphabétiques pour renforcer cette compréhension.

Ouvrez l'Explorateur de fichiers sur le côté gauche de l'IDE Web.
Accédez au répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide du répertoire ~/project et sélectionnez "Nouveau fichier".
Nommez le nouveau fichier NonLetterCheck.java.
Ouvrez le fichier NonLetterCheck.java dans l'éditeur.

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

public class NonLetterCheck {
    public static void main(String[] args) {
        char digit = '7';
        char symbol = '#';
        char space = ' ';
        char newline = '\n'; // Caractère de saut de ligne
        char tab = '\t';   // Caractère de tabulation

        System.out.println("Is '" + digit + "' lowercase? " + Character.isLowerCase(digit));
        System.out.println("Is '" + symbol + "' lowercase? " + Character.isLowerCase(symbol));
        System.out.println("Is ' ' lowercase? " + Character.isLowerCase(space));
        System.out.println("Is newline lowercase? " + Character.isLowerCase(newline));
        System.out.println("Is tab lowercase? " + Character.isLowerCase(tab));
    }
}

Dans ce programme, nous testons explicitement des caractères qui ne sont pas des lettres : un chiffre, un symbole, un espace, un caractère de saut de ligne (\n) et un caractère de tabulation (\t).

Enregistrez le fichier (Ctrl + S ou Cmd + S).

Maintenant, compilons et exécutons ce nouveau programme.

Ouvrez le Terminal en bas de l'IDE Web. Assurez-vous que vous êtes dans le répertoire ~/project.
Compilez le fichier Java :
```
javac NonLetterCheck.java
```
Exécutez le programme Java compilé :
```
java NonLetterCheck
```
Vous devriez voir la sortie suivante :
```
Is '7' lowercase? false
Is '#' lowercase? false
Is ' ' lowercase? false
Is newline lowercase? false
Is tab lowercase? false
```
Comme prévu, Character.isLowerCase() renvoie false pour tous ces caractères non alphabétiques. Cela confirme que la méthode est spécifiquement destinée à vérifier si un caractère est une lettre minuscule.

Comprendre le comportement des méthodes telles que Character.isLowerCase() avec différents types d'entrées est fondamental pour écrire un code correct et prévisible. Dans les étapes suivantes, vous pourriez explorer d'autres méthodes de la classe Character, telles que isUpperCase(), isDigit() ou isLetter().

Résumé

Dans ce laboratoire (lab), vous avez appris à vérifier si un caractère est en minuscule en Java en utilisant la méthode Character.isLowerCase(). Vous avez pratiqué l'utilisation de cette méthode en créant un fichier Java, en écrivant du code pour tester divers caractères (lettres minuscules, lettres majuscules, chiffres et symboles) et en affichant les résultats booléens dans la console. Cette pratique pratiques a démontré l'utilisation de base de Character.isLowerCase() et comment elle distingue les lettres minuscules des autres types de caractères.