Comment vérifier si une chaîne de caractères ne contient que des lettres en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères ne contient que des lettres en Java. Nous explorerons différentes techniques pour y parvenir, en commençant par une approche de base utilisant la méthode Character.isLetter() dans une boucle pour parcourir chaque caractère d'une chaîne et identifier les lettres.

Ensuite, nous plongerons dans le potentiel des expressions régulières pour vérifier efficacement si des chaînes sont composées uniquement de lettres. Enfin, nous examinerons comment gérer et vérifier les chaînes contenant un mélange de lettres majuscules et minuscules. À la fin de ce laboratoire, vous aurez une bonne compréhension des différentes méthodes de validation du contenu des chaînes en Java.

Skills Graph

Utiliser Character.isLetter() dans une boucle

Dans cette étape, nous allons explorer comment vérifier si un caractère est une lettre en Java en utilisant la méthode Character.isLetter() dans une boucle. Il s'agit d'une technique de base pour le traitement du texte et l'analyse des chaînes de caractères.

La méthode Character.isLetter() est une fonction intégrée à Java qui prend un seul caractère en entrée et renvoie true si le caractère est une lettre (majuscule ou minuscule), et false dans le cas contraire.

Nous allons utiliser une boucle for pour parcourir chaque caractère d'une chaîne de caractères et appliquer la méthode Character.isLetter().

1. Tout d'abord, créons un nouveau fichier Java nommé LetterChecker.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 LetterChecker.java.

2. Ouvrez le fichier LetterChecker.java dans l'éditeur et collez le code suivant :

   public class LetterChecker {
       public static void main(String[] args) {
           String text = "Hello123World!";
           int letterCount = 0;
   
           System.out.println("Checking 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 a letter
               if (Character.isLetter(character)) {
                   letterCount++; // Increment the counter if it's a letter
                   System.out.println("Found a letter: " + character);
               }
           }
   
           System.out.println("Total number of letters: " + letterCount);
       }
   }

   Analysons ce code :

   • String text = "Hello123World!"; : Nous définissons une variable de type chaîne de caractères text contenant un mélange de lettres et de chiffres.
   • int letterCount = 0; : Nous initialisons une variable entière letterCount pour suivre le nombre de lettres trouvées.
   • for (int i = 0; i < text.length(); i++) : Il s'agit d'une boucle for qui va parcourir du premier caractère (index 0) au dernier caractère de la chaîne text.
   • char character = text.charAt(i); : À l'intérieur de la boucle, text.charAt(i) récupère le caractère à l'index i actuel et le stocke dans la variable character.
   • if (Character.isLetter(character)) : C'est ici que nous utilisons la méthode Character.isLetter(). Elle vérifie si le character est une lettre.
   • letterCount++; : Si Character.isLetter() renvoie true, nous incrémentons letterCount.
   • System.out.println(...) : Ces lignes affichent des informations dans la console, montrant quels caractères sont des lettres et le nombre total.

3. Enregistrez le fichier LetterChecker.java (Ctrl+S ou Cmd+S).

4. Maintenant, ouvrez le terminal en bas de l'IDE Web. Assurez-vous d'être dans le répertoire ~/project. Sinon, tapez cd ~/project et appuyez sur Entrée.

5. Compilez le programme Java en utilisant la commande javac :

   javac LetterChecker.java

   S'il n'y a pas d'erreurs, cette commande créera un fichier LetterChecker.class.

6. Exécutez le programme Java compilé en utilisant la commande java :

   java LetterChecker

   Vous devriez voir une sortie similaire à celle-ci, montrant chaque lettre trouvée et le nombre total :

   Checking the string: "Hello123World!"
   Found a letter: H
   Found a letter: e
   Found a letter: l
   Found a letter: l
   Found a letter: o
   Found a letter: W
   Found a letter: o
   Found a letter: r
   Found a letter: l
   Found a letter: d
   Total number of letters: 10

Vous avez utilisé avec succès Character.isLetter() dans une boucle pour compter les lettres dans une chaîne de caractères ! Il s'agit d'une technique de base mais puissante pour le traitement du texte en Java.

Appliquer une expression régulière pour trouver les lettres

Dans cette étape, nous allons apprendre une méthode plus avancée et souvent plus efficace pour trouver les lettres dans une chaîne de caractères : l'utilisation des expressions régulières. Les expressions régulières (souvent abrégées en regex ou regexp) sont des motifs puissants utilisés pour correspondre à des combinaisons de caractères dans les chaînes de caractères.

Java offre un support intégré pour les expressions régulières via le package java.util.regex. Nous allons utiliser les classes Pattern et Matcher pour trouver toutes les occurrences de lettres dans une chaîne de caractères.

1. Créons un nouveau fichier Java nommé RegexLetterFinder.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 RegexLetterFinder.java.

2. Ouvrez le fichier RegexLetterFinder.java dans l'éditeur et collez le code suivant :

   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   public class RegexLetterFinder {
       public static void main(String[] args) {
           String text = "Hello123World!";
           String regex = "[a-zA-Z]"; // Regular expression to match any letter
   
           Pattern pattern = Pattern.compile(regex); // Compile the regex pattern
           Matcher matcher = pattern.matcher(text); // Create a matcher for the input text
   
           int letterCount = 0;
   
           System.out.println("Checking the string: \"" + text + "\" using regex: \"" + regex + "\"");
   
           // Find all matches
           while (matcher.find()) {
               letterCount++; // Increment the counter for each match
               System.out.println("Found a letter: " + matcher.group()); // Print the matched letter
           }
   
           System.out.println("Total number of letters: " + letterCount);
       }
   }

   Analysons ce nouveau code :

   • import java.util.regex.Matcher; et import java.util.regex.Pattern; : Ces lignes importent les classes nécessaires pour travailler avec les expressions régulières.
   • String regex = "[a-zA-Z]"; : C'est notre motif d'expression régulière. [a-zA-Z] est une classe de caractères qui correspond à n'importe quel caractère unique qui est soit une lettre minuscule (a à z) soit une lettre majuscule (A à Z).
   • Pattern pattern = Pattern.compile(regex); : Cette ligne compile la chaîne d'expression régulière en un objet Pattern. Compiler le motif est plus efficace si vous prévoyez d'utiliser le même motif plusieurs fois.
   • Matcher matcher = pattern.matcher(text); : Cette ligne crée un objet Matcher à partir du Pattern et du texte d'entrée. Le Matcher est utilisé pour effectuer des opérations de correspondance sur la chaîne d'entrée.
   • while (matcher.find()) : La méthode matcher.find() tente de trouver la prochaine sous - séquence de la séquence d'entrée qui correspond au motif. Elle renvoie true si une correspondance est trouvée, et false dans le cas contraire. La boucle while continue tant que des correspondances sont trouvées.
   • letterCount++; : À l'intérieur de la boucle, pour chaque correspondance trouvée, nous incrémentons le letterCount.
   • System.out.println("Found a letter: " + matcher.group()); : matcher.group() renvoie la sous - séquence qui a été correspondue par l'opération find() précédente. Nous affichons la lettre correspondante.

3. Enregistrez le fichier RegexLetterFinder.java (Ctrl+S ou Cmd+S).

4. Ouvrez le terminal en bas de l'IDE Web. Assurez - vous d'être dans le répertoire ~/project.

5. Compilez le programme Java :

   javac RegexLetterFinder.java

   Cela créera le fichier RegexLetterFinder.class.

6. Exécutez le programme Java compilé :

   java RegexLetterFinder

   Vous devriez voir une sortie similaire à celle - ci, qui est le même résultat que l'étape précédente, mais obtenu en utilisant des expressions régulières :

   Checking the string: "Hello123World!" using regex: "[a-zA-Z]"
   Found a letter: H
   Found a letter: e
   Found a letter: l
   Found a letter: l
   Found a letter: o
   Found a letter: W
   Found a letter: o
   Found a letter: r
   Found a letter: l
   Found a letter: d
   Total number of letters: 10

L'utilisation des expressions régulières peut être très puissante pour les tâches de correspondance de motifs complexes. Alors que Character.isLetter() est plus simple pour vérifier simplement des caractères individuels, les expressions régulières offrent une plus grande flexibilité pour des motifs plus complexes.

Vérifier la présence de lettres en majuscules et minuscules

Dans cette étape, nous allons nous appuyer sur nos connaissances concernant la vérification des lettres et apprendre à déterminer si une chaîne de caractères contient à la fois des lettres majuscules et minuscules. C'est une exigence courante dans la validation de mots de passe ou l'analyse de texte.

Nous allons utiliser les méthodes Character.isUpperCase() et Character.isLowerCase(), de la même manière que nous avons utilisé Character.isLetter() dans la première étape.

1. Créons un nouveau fichier Java nommé MixedCaseChecker.java dans votre répertoire ~/project. Créez le fichier en cliquant avec le bouton droit dans l'explorateur de fichiers et en tapant MixedCaseChecker.java.

2. Ouvrez le fichier MixedCaseChecker.java dans l'éditeur et collez le code suivant :

   public class MixedCaseChecker {
       public static void main(String[] args) {
           String text1 = "Hello World";
           String text2 = "hello world";
           String text3 = "HELLO WORLD";
           String text4 = "HelloWorld123";
   
           System.out.println("Checking string: \"" + text1 + "\"");
           checkMixedCase(text1);
   
           System.out.println("\nChecking string: \"" + text2 + "\"");
           checkMixedCase(text2);
   
           System.out.println("\nChecking string: \"" + text3 + "\"");
           checkMixedCase(text3);
   
           System.out.println("\nChecking string: \"" + text4 + "\"");
           checkMixedCase(text4);
       }
   
       // Method to check if a string has mixed case letters
       public static void checkMixedCase(String str) {
           boolean hasUpper = false;
           boolean hasLower = false;
   
           // Loop through each character
           for (int i = 0; i < str.length(); i++) {
               char character = str.charAt(i);
   
               // Check if it's an uppercase letter
               if (Character.isUpperCase(character)) {
                   hasUpper = true;
               }
   
               // Check if it's a lowercase letter
               if (Character.isLowerCase(character)) {
                   hasLower = true;
               }
   
               // If both upper and lower case found, we can stop early
               if (hasUpper && hasLower) {
                   break;
               }
           }
   
           // Print the result
           if (hasUpper && hasLower) {
               System.out.println("  Contains mixed case letters.");
           } else {
               System.out.println("  Does not contain mixed case letters.");
           }
       }
   }

   Examinons les parties clés de ce code :

   • public static void checkMixedCase(String str) : Nous avons créé une méthode distincte appelée checkMixedCase qui prend une chaîne de caractères en entrée et effectue la vérification. Cela rend notre méthode main plus propre et nous permet de réutiliser la logique de vérification.
   • boolean hasUpper = false; et boolean hasLower = false; : Nous utilisons des variables booléennes pour suivre si nous avons trouvé au moins une lettre majuscule et une lettre minuscule. Elles sont initialisées à false.
   • for (int i = 0; i < str.length(); i++) : Nous parcourons chaque caractère de la chaîne d'entrée str.
   • if (Character.isUpperCase(character)) : Cela vérifie si le caractère actuel character est une lettre majuscule. Si c'est le cas, nous définissons hasUpper sur true.
   • if (Character.isLowerCase(character)) : Cela vérifie si le caractère actuel character est une lettre minuscule. Si c'est le cas, nous définissons hasLower sur true.
   • if (hasUpper && hasLower) { break; } : Si nous avons trouvé à la fois une lettre majuscule et une lettre minuscule, nous savons que la chaîne contient des lettres en majuscules et minuscules, nous pouvons donc arrêter la boucle plus tôt en utilisant l'instruction break.
   • if (hasUpper && hasLower) : Après la boucle, nous vérifions si hasUpper et hasLower sont tous les deux true pour déterminer si la chaîne contient des lettres en majuscules et minuscules.

3. Enregistrez le fichier MixedCaseChecker.java (Ctrl+S ou Cmd+S).

4. Ouvrez le terminal en bas de l'IDE Web. Assurez - vous d'être dans le répertoire ~/project.

5. Compilez le programme Java :

   javac MixedCaseChecker.java

   Cela créera le fichier MixedCaseChecker.class.

6. Exécutez le programme Java compilé :

   java MixedCaseChecker

   Vous devriez voir une sortie similaire à celle - ci, indiquant si chaque chaîne de test contient des lettres en majuscules et minuscules :

   Checking string: "Hello World"
     Contains mixed case letters.
   
   Checking string: "hello world"
     Does not contain mixed case letters.
   
   Checking string: "HELLO WORLD"
     Does not contain mixed case letters.
   
   Checking string: "HelloWorld123"
     Contains mixed case letters.

Vous avez réussi à implémenter un programme Java pour vérifier la présence de lettres en majuscules et minuscules dans une chaîne de caractères en utilisant Character.isUpperCase() et Character.isLowerCase().

Résumé

Dans ce laboratoire (lab), nous avons appris à vérifier si une chaîne de caractères ne contient que des lettres en Java en utilisant deux méthodes principales. Tout d'abord, nous avons exploré l'itération à travers chaque caractère d'une chaîne et l'utilisation de la méthode Character.isLetter() pour identifier et compter les lettres. Cela a fourni une compréhension fondamentale de l'analyse au niveau des caractères.

Deuxièmement, nous avons plongé dans le potentiel des expressions régulières pour une approche plus concise et efficace de la validation pour savoir si une chaîne est composée uniquement de lettres. Nous avons également examiné comment gérer les cas où la chaîne pourrait contenir un mélange de lettres majuscules et minuscules, afin de nous assurer que nos vérifications sont exhaustives.