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

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un caractère est une lettre majuscule en Java. Nous allons explorer la méthode Character.isUpperCase(), un outil pratique fourni par la classe Character à cet effet.

Grâce à des exemples pratiques, vous verrez comment utiliser Character.isUpperCase() avec différents caractères, y compris les lettres majuscules, les lettres minuscules et les caractères non alphabétiques, pour comprendre son fonctionnement et déterminer efficacement si un caractère donné est une majuscule dans vos programmes Java.

Utiliser la méthode Character.isUpperCase()

Dans cette étape, nous allons explorer comment déterminer si un caractère est une lettre majuscule en Java en utilisant la méthode Character.isUpperCase(). Cette méthode fait partie de la classe Character, qui fournit des méthodes utiles pour manipuler des caractères individuels.

La méthode Character.isUpperCase() est une méthode statique, ce qui signifie que vous pouvez l'appeler directement sur la classe Character elle - même, sans avoir besoin de créer un objet de cette classe. Elle prend un seul caractère en argument et renvoie true si le caractère est une lettre majuscule, et false dans le cas contraire.

Créons un simple programme Java pour démontrer comment utiliser cette méthode.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        char char1 = 'A';
        char char2 = 'b';
        char char3 = '7';

        boolean isUpper1 = Character.isUpperCase(char1);
        boolean isUpper2 = Character.isUpperCase(char2);
        boolean isUpper3 = Character.isUpperCase(char3);

        System.out.println("Is '" + char1 + "' uppercase? " + isUpper1);
        System.out.println("Is '" + char2 + "' uppercase? " + isUpper2);
        System.out.println("Is '" + char3 + "' uppercase? " + isUpper3);
    }
}

Dans ce code :

Nous déclarons trois variables de type char : char1, char2 et char3, et nous leur assignons différents caractères.
Nous utilisons Character.isUpperCase() pour vérifier si chaque caractère est une majuscule et nous stockons le résultat dans des variables booléennes (isUpper1, isUpper2, isUpper3).
Enfin, nous affichons les résultats dans la console.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à ceci :

Is 'A' uppercase? true
Is 'b' uppercase? false
Is '7' uppercase? false

Cette sortie confirme que Character.isUpperCase() a correctement identifié 'A' comme une majuscule et 'b' et '7' comme n'étant pas des majuscules.

Tester avec des caractères en casse mixte

Dans l'étape précédente, nous avons utilisé Character.isUpperCase() avec des caractères individuels. Maintenant, voyons comment nous pouvons appliquer cette méthode à une chaîne de caractères (string) contenant un mélange de lettres majuscules et minuscules. Cela nous aidera à comprendre comment parcourir une chaîne de caractères et vérifier la casse de chaque caractère.

Une chaîne de caractères en Java est une séquence de caractères. Nous pouvons accéder à chaque caractère individuel dans une chaîne en utilisant la méthode charAt(), qui prend un index (position) en argument. L'index commence à 0 pour le premier caractère.

Modifions notre programme pour vérifier la casse des caractères dans une chaîne de caractères.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Remplacez le code existant par le suivant :
```
public class HelloJava {
    public static void main(String[] args) {
        String testString = "Hello Java 123";

        System.out.println("Checking characters in the string: \"" + testString + "\"");

        for (int i = 0; i < testString.length(); i++) {
            char currentChar = testString.charAt(i);
            boolean isUpper = Character.isUpperCase(currentChar);
            System.out.println("Character '" + currentChar + "' at index " + i + " is uppercase? " + isUpper);
        }
    }
}
```
Dans ce code mis à jour :
- Nous définissons une variable de type String appelée testString contenant un mélange de lettres majuscules, de lettres minuscules, d'espaces et de chiffres.
- Nous utilisons une boucle for pour parcourir chaque caractère de la chaîne. La boucle s'exécute depuis l'index 0 jusqu'à (mais sans inclure) la longueur de la chaîne.
- À l'intérieur de la boucle, testString.charAt(i) récupère le caractère à l'index i actuel.
- Nous utilisons ensuite Character.isUpperCase() pour vérifier si currentChar est une lettre majuscule.
- Enfin, nous affichons le caractère, son index et le résultat de la vérification de la majuscule.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à ceci, montrant le résultat pour chaque caractère de la chaîne :

Checking characters in the string: "Hello Java 123"
Character 'H' at index 0 is uppercase? true
Character 'e' at index 1 is uppercase? false
Character 'l' at index 2 is uppercase? false
Character 'l' at index 3 is uppercase? false
Character 'o' at index 4 is uppercase? false
Character ' ' at index 5 is uppercase? false
Character 'J' at index 6 is uppercase? true
Character 'a' at index 7 is uppercase? false
Character 'v' at index 8 is uppercase? false
Character 'a' at index 9 is uppercase? false
Character ' ' at index 10 is uppercase? false
Character '1' at index 11 is uppercase? false
Character '2' at index 12 is uppercase? false
Character '3' at index 13 is uppercase? false

Cela démontre comment Character.isUpperCase() fonctionne lorsqu'elle est appliquée à des caractères extraits d'une chaîne de caractères, en identifiant correctement 'H' et 'J' comme des lettres majuscules.

Ignorer les caractères non alphabétiques

Dans l'étape précédente, nous avons vu que Character.isUpperCase() renvoie false pour les caractères qui ne sont pas des lettres, comme les espaces et les chiffres. Souvent, lors de l'analyse d'un texte, nous ne sommes intéressés que par les lettres et souhaitons ignorer les autres caractères.

La classe Character fournit une autre méthode utile, Character.isLetter(), qui renvoie true si un caractère est une lettre (que ce soit une majuscule ou une minuscule), et false dans le cas contraire. Nous pouvons combiner Character.isLetter() et Character.isUpperCase() pour vérifier si un caractère est une lettre majuscule et ignorer les caractères non alphabétiques.

Modifions notre programme pour compter le nombre de lettres majuscules dans la chaîne, en ignorant les espaces, les chiffres et les autres caractères non alphabétiques.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Remplacez le code existant par le suivant :

public class HelloJava {
    public static void main(String[] args) {
        String testString = "Hello Java 123";
        int uppercaseCount = 0;

        System.out.println("Counting uppercase letters in the string: \"" + testString + "\"");

        for (int i = 0; i < testString.length(); i++) {
            char currentChar = testString.charAt(i);

            // Check if the character is a letter AND if it is uppercase
            if (Character.isLetter(currentChar) && Character.isUpperCase(currentChar)) {
                uppercaseCount++;
                System.out.println("Found uppercase letter: '" + currentChar + "' at index " + i);
            }
        }

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

Dans ce code :

Nous initialisons une variable entière uppercaseCount à 0.
À l'intérieur de la boucle, nous ajoutons une condition if : if (Character.isLetter(currentChar) && Character.isUpperCase(currentChar)). L'opérateur && signifie "et". Cette condition est vraie seulement si Character.isLetter(currentChar) est vraie et Character.isUpperCase(currentChar) est vraie.
Si la condition est vraie, nous incrémentons uppercaseCount et affichons un message indiquant qu'une lettre majuscule a été trouvée.
Après que la boucle se termine, nous affichons le nombre total de lettres majuscules.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme dans le terminal :
```
javac HelloJava.java
```

Exécutez le programme compilé :

java HelloJava

Vous devriez voir une sortie similaire à ceci :

Counting uppercase letters in the string: "Hello Java 123"
Found uppercase letter: 'H' at index 0
Found uppercase letter: 'J' at index 6
Total uppercase letters found: 2

Cette sortie montre que notre programme a correctement identifié et compté seulement les lettres majuscules ('H' et 'J'), en ignorant les lettres minuscules, les espaces et les chiffres.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si un caractère est en majuscule en Java en utilisant la méthode statique Character.isUpperCase(). Cette méthode prend un seul caractère en entrée et renvoie une valeur booléenne indiquant si le caractère est une lettre majuscule. Nous avons démontré son utilisation avec un simple programme Java, en le testant avec des caractères majuscules, minuscules et non alphabétiques pour observer les résultats booléens renvoyés.