Comment vérifier si une chaîne de caractères correspond à un format de numéro de téléphone en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si une chaîne de caractères correspond à un format de numéro de téléphone en Java en utilisant les expressions régulières (Regular Expressions - Regex). Nous commencerons par créer un modèle d'expression régulière spécifiquement conçu pour correspondre aux formats de numéros de téléphone courants.

Ensuite, vous allez valider une chaîne de caractères représentant un numéro de téléphone donné par rapport au modèle d'expression régulière créé en utilisant la classe Matcher de Java. Enfin, vous explorerez comment gérer et correspondre aux différentes variantes de formats de numéros de téléphone en ajustant le modèle d'expression régulière.

Skills Graph

Créer une expression régulière pour les numéros de téléphone

Dans cette étape, nous allons apprendre les expressions régulières (Regular Expressions - Regex) et comment en créer une pour correspondre aux numéros de téléphone. Les expressions régulières sont un outil puissant utilisé pour la correspondance de motifs dans les chaînes de caractères. C'est comme un langage spécial pour décrire les motifs de texte.

Pourquoi avons-nous besoin d'expressions régulières pour les numéros de téléphone ? Les numéros de téléphone peuvent avoir de nombreux formats (par exemple, 123-456-7890, (123) 456-7890, 123.456.7890). Les expressions régulières nous permettent de définir un motif qui correspond à toutes ces variantes.

Créons un simple programme Java qui utilise les expressions régulières pour vérifier si une chaîne de caractères ressemble à un numéro de téléphone.

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

2. Remplacez tout le contenu du fichier par le code suivant :

   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   public class HelloJava {
       public static void main(String[] args) {
           String phoneNumber = "123-456-7890"; // La chaîne à vérifier
           String regex = "\\d{3}-\\d{3}-\\d{4}"; // Le motif d'expression régulière
   
           Pattern pattern = Pattern.compile(regex);
           Matcher matcher = pattern.matcher(phoneNumber);
   
           boolean isMatch = matcher.matches();
   
           if (isMatch) {
               System.out.println(phoneNumber + " est un format de numéro de téléphone valide.");
           } else {
               System.out.println(phoneNumber + " n'est pas un format de numéro de téléphone valide.");
           }
       }
   }

   Examinons les nouvelles parties de ce 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 en Java.
   • String phoneNumber = "123-456-7890"; : C'est la chaîne que nous voulons tester.
   • String regex = "\\d{3}-\\d{3}-\\d{4}"; : C'est notre premier motif d'expression régulière. Décortiquons-le :
     • \\d : Correspond à n'importe quel chiffre (0 - 9). Nous utilisons \\ car \ est un caractère spécial dans les chaînes de caractères Java, nous devons donc l'échapper.
     • {3} : Correspond exactement 3 fois à l'élément précédent.
     • - : Correspond littéralement au caractère tiret.
     • Ainsi, \\d{3}-\\d{3}-\\d{4} correspond à trois chiffres, suivis d'un tiret, suivis de trois chiffres, suivis d'un tiret, suivis de quatre chiffres.
   • Pattern pattern = Pattern.compile(regex); : Cela compile la chaîne d'expression régulière en un objet Pattern, qui est plus efficace pour les correspondances répétées.
   • Matcher matcher = pattern.matcher(phoneNumber); : Cela crée un objet Matcher qui effectuera l'opération de correspondance sur notre chaîne phoneNumber en utilisant le pattern compilé.
   • boolean isMatch = matcher.matches(); : Cela tente de faire correspondre l'entière chaîne d'entrée (phoneNumber) au motif. Il renvoie true si l'ensemble de la chaîne correspond, et false sinon.
   • Le bloc if et else affiche simplement un message en fonction de si la chaîne correspond au motif.

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

4. Compilez le programme dans le terminal :

   javac HelloJava.java

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

5. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir la sortie indiquant que "123-456-7890" est un format de numéro de téléphone valide selon notre simple expression régulière.

Dans cette étape, vous avez appris les bases de l'utilisation des expressions régulières en Java et créé un simple motif pour correspondre à un format de numéro de téléphone spécifique. Dans les étapes suivantes, nous allons rendre notre expression régulière plus flexible pour gérer différents formats.

Valider un numéro de téléphone avec le Matcher

Dans l'étape précédente, nous avons créé un simple motif d'expression régulière et utilisé la méthode matches() de la classe Matcher pour vérifier si une chaîne entière correspondait au motif. Dans cette étape, nous allons explorer plus en détail la classe Matcher et voir comment elle fonctionne.

La classe Matcher est le moteur qui effectue les opérations de correspondance. Elle est créée à partir d'un objet Pattern et est utilisée pour trouver les occurrences du motif dans une chaîne d'entrée.

Modifions notre programme pour tester une chaîne différente et voir comment se comporte la méthode matches().

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

2. Changez la chaîne phoneNumber pour quelque chose qui ne correspond pas exactement à notre motif actuel \\d{3}-\\d{3}-\\d{4}. Par exemple, changez la ligne :

   String phoneNumber = "123-456-7890"; // The string to check

   en :

   String phoneNumber = "My phone number is 123-456-7890."; // The string to check

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

4. Compilez le programme modifié dans le terminal :

   javac HelloJava.java

5. Exécutez le programme compilé :

   java HelloJava

   Cette fois, la sortie devrait être :

   My phone number is 123-456-7890. is not a valid phone number format.

   Pourquoi cela s'est-il produit ? Parce que la méthode matches() tente de faire correspondre l'entière chaîne d'entrée au motif. Étant donné que notre chaîne d'entrée contient plus que simplement le motif de numéro de téléphone, matches() renvoie false.

   Si nous voulions savoir si le motif existe n'importe où dans la chaîne, nous utiliserions une méthode différente, comme find(), que nous explorerons plus tard. Pour l'instant, nous nous concentrons sur la validation de savoir si l'entière chaîne correspond à un format spécifique en utilisant matches().

   Comprendre la différence entre matches() et find() est crucial lorsque vous travaillez avec les expressions régulières en Java. matches() est utilisé pour une validation stricte de l'ensemble de la chaîne, tandis que find() est utilisé pour rechercher le motif dans une chaîne plus longue.

Dans cette étape, vous avez vu comment fonctionne la méthode matches() de la classe Matcher et pourquoi il est important de comprendre son comportement lors de la validation des formats de chaînes.

Gérer différents formats de numéros de téléphone

Dans le monde réel, les numéros de téléphone ne suivent pas toujours exactement le format XXX-XXX-XXXX. Ils peuvent utiliser des points (.), des espaces ( ) ou même des parenthèses (()). Dans cette étape, nous allons modifier notre motif d'expression régulière pour gérer certaines de ces variantes.

Nous allons introduire quelques concepts supplémentaires d'expressions régulières pour rendre notre motif plus flexible :

• ? : Rend l'élément précédent facultatif (0 ou 1 fois).
• * : Correspond à l'élément précédent zéro fois ou plus.
• + : Correspond à l'élément précédent une fois ou plus.
• [] : Définit un ensemble de caractères. Correspond à n'importe quel caractère unique contenu entre les crochets.
• | : Agit comme un opérateur OU. Correspond soit au motif avant, soit au motif après le |.

Mettons à jour notre fichier HelloJava.java pour utiliser un motif d'expression régulière plus flexible.

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

2. Changez la chaîne regex comme suit :

   String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern

   Décortiquons ce nouveau motif :

   • \\(? : Correspond à une parenthèse ouvrante facultative (. Nous avons besoin de \\ pour échapper la signification spéciale de ( dans les expressions régulières, et ? la rend facultative.
   • \\d{3} : Correspond exactement à trois chiffres.
   • \\)? : Correspond à une parenthèse fermante facultative ).
   • [-.\\s]? : C'est un ensemble de caractères [] qui correspond soit à un tiret (-), à un point (.), soit à un caractère d'espace blanc (\\s). Le ? rend ce séparateur facultatif.
   • \\d{3} : Correspond exactement à trois chiffres.
   • [-.\\s]? : Correspond de nouveau à un séparateur facultatif (tiret, point ou espace blanc).
   • \\d{4} : Correspond exactement à quatre chiffres.

   Ce motif peut maintenant correspondre à des formats tels que 123-456-7890, (123) 456-7890, 123.456.7890, 123 456 7890 et même 1234567890 (sans aucun séparateur).

3. Maintenant, testons ce nouveau motif avec différents formats de numéros de téléphone. Remplacez la chaîne phoneNumber par quelques exemples différents :

   import java.util.regex.Matcher;
   import java.util.regex.Pattern;
   
   public class HelloJava {
       public static void main(String[] args) {
           String[] phoneNumbers = {
               "123-456-7890",
               "(123) 456-7890",
               "123.456.7890",
               "123 456 7890",
               "1234567890",
               "invalid-number", // This should not match
               "123-456-789" // This should not match
           };
   
           String regex = "\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}"; // More flexible regex pattern
   
           Pattern pattern = Pattern.compile(regex);
   
           for (String phoneNumber : phoneNumbers) {
               Matcher matcher = pattern.matcher(phoneNumber);
               boolean isMatch = matcher.matches();
   
               if (isMatch) {
                   System.out.println(phoneNumber + " is a valid phone number format.");
               } else {
                   System.out.println(phoneNumber + " is not a valid phone number format.");
               }
           }
       }
   }

   Nous avons introduit un tableau de chaînes phoneNumbers pour tester facilement plusieurs entrées et une boucle for pour les parcourir.

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

5. Compilez le programme dans le terminal :

   javac HelloJava.java

6. Exécutez le programme compilé :

   java HelloJava

   Vous devriez voir une sortie similaire à celle-ci, indiquant quelles chaînes correspondent au motif :

   123-456-7890 is a valid phone number format.
   (123) 456-7890 is a valid phone number format.
   123.456.7890 is a valid phone number format.
   123 456 7890 is a valid phone number format.
   1234567890 is a valid phone number format.
   invalid-number is not a valid phone number format.
   123-456-789 is not a valid phone number format.

Vous avez maintenant créé un motif d'expression régulière plus robuste qui peut gérer plusieurs formats de numéros de téléphone courants. Cela démontre la puissance et la flexibilité des expressions régulières pour valider et analyser les chaînes de caractères.

Résumé

Dans ce laboratoire, nous avons appris à vérifier si une chaîne de caractères correspond à un format de numéro de téléphone en Java en utilisant les expressions régulières (Regex). Nous avons commencé par comprendre le concept des expressions régulières et leur importance pour la correspondance de motifs, en particulier pour gérer différents formats de numéros de téléphone. Nous avons ensuite créé un simple programme Java utilisant le package java.util.regex.

La première étape a consisté à créer un motif d'expression régulière de base \\d{3}-\\d{3}-\\d{4} pour correspondre au format "XXX-XXX-XXXX". Nous avons utilisé Pattern.compile() pour compiler l'expression régulière en un objet Pattern et Pattern.matcher() pour créer un objet Matcher pour la chaîne d'entrée. Enfin, nous avons utilisé matcher.matches() pour vérifier si l'ensemble de la chaîne correspondait au motif et avons imprimé le résultat. Cela a jeté les bases de la validation des numéros de téléphone à l'aide d'expressions régulières en Java.