Comment vérifier si une chaîne de caractères est en majuscules en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères est en majuscules en Java. Nous explorerons différentes méthodes pour y parvenir, en commençant par comparer la chaîne originale à sa version en majuscules en utilisant la méthode toUpperCase().

Ensuite, vous apprendrez à parcourir une chaîne de caractères et à utiliser la méthode Character.isUpperCase() pour vérifier la casse de chaque caractère individuel. Enfin, nous aborderons la question de la gestion des caractères non alphabétiques dans la chaîne lors de ces vérifications.

Comparer une chaîne avec toUpperCase()

Dans cette étape, nous apprendrons à comparer des chaînes de caractères en Java, en particulier à effectuer des comparaisons insensibles à la casse. C'est une tâche courante en programmation, par exemple, lorsque vous vérifiez si un utilisateur a saisi "yes", "Yes" ou "YES".

Tout d'abord, créons un nouveau fichier Java nommé StringCompare.java dans votre répertoire ~/project. Vous pouvez le faire en cliquant avec le bouton droit dans l'explorateur de fichiers à gauche et en sélectionnant "Nouveau fichier", puis en tapant StringCompare.java.

Maintenant, ouvrez le fichier StringCompare.java dans l'éditeur et ajoutez le code suivant :

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

        // Comparaison sensible à la casse
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Comparaison sensible à la casse: " + areEqualCaseSensitive);

        // Comparaison insensible à la casse en utilisant toUpperCase()
        boolean areEqualCaseInsensitive = str1.toUpperCase().equals(str2.toUpperCase());
        System.out.println("Comparaison insensible à la casse en utilisant toUpperCase(): " + areEqualCaseInsensitive);
    }
}

Décortiquons ce code :

Nous déclarons deux variables de type String, str1 et str2, avec des casse différentes.
str1.equals(str2) effectue une comparaison sensible à la casse. Elle retournera true seulement si les chaînes de caractères sont exactement les mêmes, y compris la casse des lettres.
str1.toUpperCase() convertit str1 en majuscules ("HELLO").
str2.toUpperCase() convertit str2 en majuscules ("HELLO").
Nous utilisons ensuite .equals() pour comparer les versions en majuscules des chaînes de caractères, effectuant ainsi une comparaison insensible à la casse.

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

Maintenant, compilons et exécutons ce programme dans le terminal. Assurez-vous d'être dans le répertoire ~/project.

Compilez le code :

javac StringCompare.java

S'il n'y a pas d'erreurs, un fichier StringCompare.class sera créé.

Maintenant, exécutez le code compilé :

java StringCompare

Vous devriez voir la sortie suivante :

Comparaison sensible à la casse: false
Comparaison insensible à la casse en utilisant toUpperCase(): true

Cette sortie montre que la comparaison sensible à la casse (equals()) retourne false car "Hello" et "hello" sont différents en raison de la casse, tandis que la comparaison insensible à la casse en utilisant toUpperCase() retourne true car les deux chaînes deviennent "HELLO" lorsqu'elles sont converties en majuscules.

Utiliser toUpperCase() (ou toLowerCase()) avant de comparer des chaînes de caractères est une méthode courante pour effectuer des comparaisons insensibles à la casse en Java.

Utiliser Character.isUpperCase() dans une boucle

Dans l'étape précédente, nous avons appris à comparer des chaînes de caractères entières de manière insensible à la casse. Maintenant, explorons comment examiner les caractères individuels d'une chaîne de caractères et déterminer s'ils sont en majuscules. Cela est utile lorsque vous avez besoin d'analyser la structure d'une chaîne de caractères, par exemple pour compter le nombre de lettres majuscules ou valider le format d'une entrée.

Java fournit la classe Character, qui dispose de méthodes utiles pour travailler avec des caractères individuels. Une de ces méthodes est isUpperCase(), qui vérifie si un caractère donné est une lettre majuscule.

Modifions notre fichier StringCompare.java pour illustrer cela. Ouvrez ~/project/StringCompare.java dans l'éditeur et remplacez son contenu par le code suivant :

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

Comprenons les nouvelles parties de ce code :

Nous déclarons une variable de type String nommée text et une variable entière uppercaseCount initialisée à 0.
Nous utilisons une boucle for pour parcourir chaque caractère de la chaîne text. La boucle s'exécute depuis l'index 0 jusqu'à (mais sans inclure) la longueur de la chaîne.
text.charAt(i) récupère le caractère à l'index i actuel dans la chaîne.
Character.isUpperCase(character) vérifie si le caractère est une lettre majuscule. Cette méthode retourne true si le caractère est en majuscules et false sinon.
Si isUpperCase() retourne true, nous affichons un message indiquant le caractère majuscule et son index, et nous incrémentons uppercaseCount.

Enregistrez le fichier (Ctrl + S).

Maintenant, compilez et exécutez le programme modifié dans le terminal depuis le répertoire ~/project :

Compilez :

javac StringCompare.java

Exécutez :

java StringCompare

Vous devriez voir une sortie similaire à celle-ci :

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

Cette sortie montre que notre programme a correctement identifié les caractères majuscules 'H' et 'W' dans la chaîne et les a comptés.

Utiliser Character.isUpperCase() dans une boucle est une technique puissante pour analyser des chaînes de caractères caractère par caractère. Dans l'étape suivante, nous verrons comment gérer les caractères qui ne sont pas des lettres.

Gérer les caractères non alphabétiques

Dans l'étape précédente, nous avons utilisé Character.isUpperCase() pour identifier les lettres majuscules. Cependant, les chaînes de caractères peuvent contenir plus que simplement des lettres - elles peuvent inclure des nombres, des symboles, des espaces et des ponctuations. Lors de l'analyse de chaînes de caractères, il est souvent nécessaire de distinguer entre différents types de caractères.

La classe Character fournit d'autres méthodes utiles à cet effet, telles que :

Character.isLetter(char ch) : Vérifie si un caractère est une lettre.
Character.isDigit(char ch) : Vérifie si un caractère est un chiffre (0 - 9).
Character.isWhitespace(char ch) : Vérifie si un caractère est un caractère d'espacement (comme l'espace, la tabulation, le saut de ligne).

Modifions à nouveau notre fichier StringCompare.java pour montrer comment gérer les caractères non alphabétiques et compter différents types de caractères dans une chaîne. Ouvrez ~/project/StringCompare.java dans l'éditeur et remplacez son contenu par le code suivant :

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

Dans ce code mis à jour :

Nous initialisons des compteurs pour les lettres, les chiffres, les caractères d'espacement et les autres caractères.
À l'intérieur de la boucle, nous utilisons des instructions if - else if - else pour vérifier le type de chaque caractère en utilisant Character.isLetter(), Character.isDigit() et Character.isWhitespace().
Nous incrémentons le compteur correspondant en fonction du type de caractère.
Enfin, nous affichons les compteurs pour chaque type de caractère.

Enregistrez le fichier (Ctrl + S).

Maintenant, compilez et exécutez le programme dans le terminal depuis le répertoire ~/project :

Compilez :

javac StringCompare.java

Exécutez :

java StringCompare

Vous devriez voir une sortie similaire à celle-ci :

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

Cette sortie identifie et compte correctement les différents types de caractères dans la chaîne "Hello World 123!". Les lettres sont 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' (10 au total). Les chiffres sont '1', '2', '3' (3 au total). Les caractères d'espacement sont l'espace entre "Hello" et "World", et l'espace entre "World" et "123" (2 au total). L'autre caractère est '!' (1 au total). Le compte total est 10 + 3 + 2 + 1 = 16, ce qui correspond à la longueur de la chaîne.

En utilisant des méthodes telles que Character.isLetter(), Character.isDigit() et Character.isWhitespace(), vous pouvez écrire un code plus robuste capable de gérer différents types de caractères dans une chaîne. Cela est crucial pour des tâches telles que la validation de données, l'analyse d'entrées ou l'analyse de texte.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères est en majuscules en Java. Nous avons exploré deux méthodes principales. Premièrement, nous avons comparé une chaîne avec sa version en majuscules en utilisant la méthode toUpperCase() et la méthode equals() pour effectuer une comparaison insensible à la casse. Cette méthode est utile pour vérifier si deux chaînes sont identiques, quelle que soit leur casse.

Deuxièmement, nous avons appris à parcourir une chaîne de caractères et à utiliser la méthode Character.isUpperCase() dans une boucle pour vérifier si chaque caractère est une lettre majuscule. Nous avons également considéré comment gérer les caractères non alphabétiques pendant ce processus, afin de nous assurer que notre vérification est robuste. Ces techniques offrent différentes approches pour déterminer l'état en majuscules d'une chaîne en fonction des exigences spécifiques de la tâche.