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

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères est en minuscules en Java. Nous explorerons différentes méthodes pour y parvenir, en commençant par la comparaison de chaînes tout en ignorant la casse à l'aide de toLowerCase() et equalsIgnoreCase().

Vous apprendrez ensuite à parcourir une chaîne de caractères et à utiliser Character.isLowerCase() pour vérifier chaque caractère individuellement. Enfin, nous aborderons la question de la gestion des caractères non alphabétiques lors de cette vérification.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/StringManipulationGroup(["String Manipulation"]) java(("Java")) -.-> java/SystemandDataProcessingGroup(["System and Data Processing"]) java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java/BasicSyntaxGroup -.-> java/for_loop("For Loop") java/StringManipulationGroup -.-> java/strings("Strings") java/SystemandDataProcessingGroup -.-> java/string_methods("String Methods") subgraph Lab Skills java/for_loop -.-> lab-559986{{"Comment vérifier si une chaîne de caractères est en minuscules en Java"}} java/strings -.-> lab-559986{{"Comment vérifier si une chaîne de caractères est en minuscules en Java"}} java/string_methods -.-> lab-559986{{"Comment vérifier si une chaîne de caractères est en minuscules en Java"}} end

Comparer des chaînes de caractères avec toLowerCase()

Dans cette étape, nous apprendrons à comparer des chaînes de caractères en Java tout en ignorant la casse des lettres. C'est une tâche courante lorsque vous souhaitez vérifier si deux chaînes de caractères sont identiques, qu'elles utilisent des lettres majuscules ou minuscules.

Créons un nouveau fichier Java pour pratiquer cela.

Ouvrez l'WebIDE s'il n'est pas déjà ouvert.
Dans l'explorateur de fichiers à gauche, assurez-vous d'être dans le répertoire ~/project.
Cliquez avec le bouton droit dans l'espace vide de l'explorateur de fichiers, sélectionnez "Nouveau fichier" et nommez-le CaseInsensitiveCompare.java.
Ouvrez le fichier CaseInsensitiveCompare.java dans l'éditeur.

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

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

        // Comparing strings directly (case-sensitive)
        boolean areEqualCaseSensitive = str1.equals(str2);
        System.out.println("Case-sensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseSensitive);

        // Comparing strings ignoring case
        boolean areEqualCaseInsensitive = str1.equalsIgnoreCase(str2);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str2 + "\": " + areEqualCaseInsensitive);

        // Comparing str1 and str3 ignoring case
        boolean areEqualStr1Str3 = str1.equalsIgnoreCase(str3);
        System.out.println("Case-insensitive comparison of \"" + str1 + "\" and \"" + str3 + "\": " + areEqualStr1Str3);
    }
}

Dans ce code :

Nous déclarons trois variables de type String : str1, str2 et str3.
str1.equals(str2) effectue une comparaison sensible à la casse. Elle retournera false car "Hello" et "hello" sont différents en raison de la majuscule 'H'.
str1.equalsIgnoreCase(str2) effectue une comparaison insensible à la casse. Elle retournera true car "Hello" et "hello" sont identiques lorsque la casse est ignorée.
Nous comparons également str1 et str3 en ignorant la casse pour montrer que des mots différents sont toujours considérés comme différents.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'WebIDE. Assurez-vous d'être dans le répertoire ~/project.
Compilez le programme Java en utilisant la commande javac :
```
javac CaseInsensitiveCompare.java
```
S'il n'y a pas d'erreurs, vous ne verrez aucun résultat. Un fichier CaseInsensitiveCompare.class sera créé dans le répertoire ~/project.
Exécutez le programme Java compilé en utilisant la commande java :
```
java CaseInsensitiveCompare
```
Vous devriez voir la sortie suivante :
```
Case-sensitive comparison of "Hello" and "hello": false
Case-insensitive comparison of "Hello" and "hello": true
Case-insensitive comparison of "Hello" and "World": false
```
Cette sortie confirme que equals() est sensible à la casse, tandis que equalsIgnoreCase() ignore la casse.

L'utilisation de equalsIgnoreCase() est un moyen pratique de comparer des chaînes de caractères sans se soucier de savoir si les lettres sont en majuscules ou en minuscules.

Utiliser Character.isLowerCase() dans une boucle

Dans l'étape précédente, nous avons appris à comparer des chaînes de caractères entières tout en ignorant la casse. Parfois, vous devrez peut-être examiner chaque caractère individuellement dans une chaîne de caractères et vérifier s'ils sont en minuscules ou en majuscules. Java propose des méthodes utiles pour cela dans la classe Character.

Dans cette étape, nous allons utiliser la méthode Character.isLowerCase() dans une boucle pour compter le nombre de lettres minuscules dans une chaîne de caractères.

Ouvrez l'WebIDE s'il n'est pas déjà ouvert.
Dans l'explorateur de fichiers à gauche, assurez-vous d'être dans le répertoire ~/project.
Créez un nouveau fichier nommé CountLowercase.java dans le répertoire ~/project.
Ouvrez le fichier CountLowercase.java dans l'éditeur.
Copiez et collez le code suivant dans l'éditeur :
```
public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;

        // 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 a lowercase letter
            if (Character.isLowerCase(character)) {
                lowercaseCount++; // Increment the counter if it's lowercase
            }
        }

        System.out.println("The string is: \"" + text + "\"");
        System.out.println("Number of lowercase letters: " + lowercaseCount);
    }
}
```
Analysons ce code :
- Nous avons une variable String nommée text qui contient un mélange de lettres majuscules, de lettres minuscules, de chiffres et de symboles.
- Nous initialisons une variable entière lowercaseCount à 0. Cette variable stockera le nombre de lettres minuscules.
- Nous utilisons une boucle for pour parcourir chaque caractère de la chaîne de caractères. La boucle s'exécute depuis l'index 0 jusqu'à (mais sans inclure) la longueur de la chaîne de caractères.
- text.charAt(i) récupère le caractère à l'index i actuel.
- Character.isLowerCase(character) est une méthode qui retourne true si le character donné est une lettre minuscule, et false dans le cas contraire.
- Si Character.isLowerCase() retourne true, nous incrémentons lowercaseCount.
- Enfin, nous affichons la chaîne de caractères originale et le nombre total de lettres minuscules.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'WebIDE. Assurez-vous d'être dans le répertoire ~/project.
Compilez le programme Java :
```
javac CountLowercase.java
```
Si la compilation réussit, un fichier CountLowercase.class sera créé.
Exécutez le programme Java compilé :
```
java CountLowercase
```
Vous devriez voir la sortie suivante :
```
The string is: "Hello World 123!"
Number of lowercase letters: 8
```
La sortie montre qu'il y a 8 lettres minuscules dans la chaîne de caractères "Hello World 123!" ('e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd').

L'utilisation de Character.isLowerCase() dans une boucle vous permet d'effectuer une analyse caractère par caractère d'une chaîne de caractères, ce qui est utile pour diverses tâches de traitement de texte.

Ignorer les caractères non alphabétiques

Dans l'étape précédente, nous avons compté les lettres minuscules. Cependant, les chaînes de caractères peuvent contenir différents types de caractères tels que des chiffres, des espaces et des symboles. Lorsque vous comparez des chaînes de caractères ou analysez leur contenu, vous souhaiterez souvent ignorer ces caractères non alphabétiques.

Dans cette étape, nous allons modifier notre programme pour traiter uniquement les caractères alphabétiques et ignorer tout le reste. Nous allons utiliser la méthode Character.isLetter() à cet effet.

Ouvrez l'WebIDE s'il n'est pas déjà ouvert.
Ouvrez le fichier CountLowercase.java que vous avez créé dans l'étape précédente.

Modifiez le code pour inclure une vérification pour savoir si un caractère est une lettre avant de vérifier s'il est en minuscule. Remplacez le code existant par le suivant :

public class CountLowercase {
    public static void main(String[] args) {
        String text = "Hello World 123!";
        int lowercaseCount = 0;
        StringBuilder lettersOnly = new StringBuilder(); // To store only letter characters

        // 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 a letter
            if (Character.isLetter(character)) {
                lettersOnly.append(character); // Add the letter to our new string

                // Check if the letter is lowercase
                if (Character.isLowerCase(character)) {
                    lowercaseCount++; // Increment the counter if it's lowercase
                }
            }
        }

        System.out.println("The original string is: \"" + text + "\"");
        System.out.println("Letters only string: \"" + lettersOnly.toString() + "\"");
        System.out.println("Number of lowercase letters (ignoring non-letters): " + lowercaseCount);
    }
}

Voici ce que nous avons ajouté et modifié :

Nous avons introduit un StringBuilder appelé lettersOnly. StringBuilder est utilisé pour construire efficacement des chaînes de caractères, notamment lorsque vous ajoutez des caractères dans une boucle.
À l'intérieur de la boucle, nous avons ajouté une condition if (Character.isLetter(character)). Cela vérifie si le character actuel est une lettre (en majuscule ou en minuscule).
Si le caractère est une lettre, nous l'ajoutons au StringBuilder lettersOnly en utilisant lettersOnly.append(character).
La vérification Character.isLowerCase(character) est maintenant imbriquée dans la vérification Character.isLetter(), ce qui garantit que nous ne comptons que les lettres minuscules parmi les caractères qui sont effectivement des lettres.
Enfin, nous affichons la chaîne de caractères originale, la chaîne ne contenant que des lettres et le nombre de lettres minuscules parmi ces lettres.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Ouvrez le terminal en bas de l'WebIDE. Assurez-vous d'être dans le répertoire ~/project.
Compilez le programme Java modifié :
```
javac CountLowercase.java
```
Assurez-vous qu'il n'y a pas d'erreurs de compilation.
Exécutez le programme Java compilé :
```
java CountLowercase
```
Vous devriez voir la sortie suivante :
```
The original string is: "Hello World 123!"
Letters only string: "HelloWorld"
Number of lowercase letters (ignoring non-letters): 8
```
Notez que la "chaîne ne contenant que des lettres" contient maintenant seulement "HelloWorld", et le nombre de lettres minuscules est toujours de 8, car nous ne comptons que les lettres minuscules parmi les caractères qui sont effectivement des lettres.

L'utilisation de Character.isLetter() est très utile lorsque vous avez besoin de filtrer les caractères non alphabétiques d'une chaîne de caractères avant de la traiter plus avant.

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères est en minuscules en Java. Nous avons exploré deux méthodes principales. Premièrement, nous avons comparé des chaînes de caractères en utilisant equalsIgnoreCase() pour effectuer des comparaisons insensibles à la casse, montrant ainsi comment vérifier si deux chaînes de caractères sont identiques, indépendamment de la casse des lettres.

Deuxièmement, bien que les détails complets n'aient pas été fournis, les étapes indiquent que nous allons apprendre à parcourir une chaîne de caractères à l'aide d'une boucle et à utiliser Character.isLowerCase() pour vérifier si des caractères individuels sont en minuscules, tout en tenant compte de la manière d'ignorer les caractères non alphabétiques au cours de ce processus.