Comment vérifier si une chaîne de caractères correspond à un format d'e - mail en Java

Introduction

Dans ce laboratoire, vous apprendrez à valider si une chaîne de caractères donnée correspond à un format d'e-mail standard en Java en utilisant des expressions régulières. Nous allons définir un motif d'expression régulière approprié, utiliser la méthode Pattern.matches() pour la validation, et tester notre implémentation avec diverses adresses e-mail valides et invalides pour nous assurer qu'elle fonctionne correctement. Cette activité pratique vous offrira une expérience concrète des capacités des expressions régulières de Java pour la correspondance de motifs de chaînes de caractères.

Skills Graph

Définir le motif d'expression régulière pour les e-mails

Dans cette étape, nous allons commencer par définir le motif d'expression régulière que nous utiliserons pour valider les adresses e-mail. Les expressions régulières, souvent abrégées en "regex" ou "regexp", sont des séquences de caractères qui définissent un motif de recherche. Elles sont extrêmement puissantes pour la correspondance de motifs et la manipulation de chaînes de caractères.

Pour la validation des e-mails, un motif d'expression régulière nous aide à vérifier si une chaîne de caractères donnée suit le format standard d'une adresse e-mail (par exemple, [email protected]). Bien qu'une expression régulière parfaite pour toutes les adresses e-mail valides possibles soit très complexe, nous pouvons définir un motif qui couvre la plupart des formats courants et valides.

Nous allons créer un nouveau fichier Java pour contenir notre code.

1. Ouvrez le WebIDE s'il n'est pas déjà ouvert. Vous devriez être par défaut dans le répertoire ~/project.

2. Dans l'explorateur de fichiers à gauche, cliquez avec le bouton droit dans l'espace vide et sélectionnez "Nouveau fichier". Nommez le fichier EmailValidator.java.

3. Ouvrez le fichier EmailValidator.java dans l'éditeur en cliquant dessus dans l'explorateur de fichiers.

4. Maintenant, ajoutons la structure de base de notre classe Java et définissons le motif d'expression régulière. Copiez et collez le code suivant dans le fichier EmailValidator.java :

   import java.util.regex.Pattern;
   
   public class EmailValidator {
   
       // Email regex pattern
       private static final String EMAIL_REGEX =
               "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
   
       public static void main(String[] args) {
           // We will add code here in the next steps
       }
   }

   Examinons brièvement les nouvelles parties :

   • import java.util.regex.Pattern; : Cette ligne importe la classe Pattern, qui fait partie du support intégré des expressions régulières de Java.
   • private static final String EMAIL_REGEX = "..."; : Cette ligne déclare une variable constante nommée EMAIL_REGEX et lui assigne notre motif d'expression régulière.
     • ^ : Correspond au début de la chaîne de caractères.
     • [a-zA-Z0-9_+&*-]+ : Correspond à un ou plusieurs caractères alphanumériques ou _, +, &, *, -. Cela correspond à la partie nom d'utilisateur.
     • (?:\\.[a-zA-Z0-9_+&*-]+)* : Correspond à zéro ou plusieurs occurrences d'un point suivi de plus de caractères de nom d'utilisateur. Cela permet d'avoir des points dans le nom d'utilisateur (par exemple, first.last).
     • @ : Correspond au symbole "@" littéral.
     • (?:[a-zA-Z0-9-]+\\.)+ : Correspond à une ou plusieurs occurrences de caractères alphanumériques ou - suivis d'un point. Cela correspond au nom de domaine (par exemple, domain.).
     • [a-zA-Z]{2,7} : Correspond à 2 à 7 caractères alphabétiques pour le domaine de premier niveau (par exemple, com, org, codes de pays).
     • $ : Correspond à la fin de la chaîne de caractères.

   Ne vous inquiétez pas si le motif d'expression régulière semble compliqué. Comprendre tous les détails des motifs d'expressions régulières complexes prend du temps et de la pratique. Pour l'instant, concentrez-vous sur le fait que cette chaîne définit la règle pour ce qu'est une adresse e-mail valide.

5. Enregistrez le fichier EmailValidator.java (Ctrl+S ou Cmd+S).

Vous avez maintenant créé avec succès le fichier Java et défini le motif d'expression régulière pour la validation des e-mails. Dans l'étape suivante, nous utiliserons ce motif pour valider des adresses e-mail réelles.

Utiliser Pattern.matches() pour la validation d'e-mail

Dans cette étape, nous allons apprendre à utiliser la méthode Pattern.matches() en Java pour vérifier si une chaîne de caractères donnée correspond au motif d'expression régulière d'e-mail que nous avons défini. La méthode Pattern.matches(regex, input) est un moyen pratique d'effectuer une simple correspondance d'une chaîne d'entrée entière avec une expression régulière. Elle retourne true si la chaîne d'entrée entière correspond à l'expression régulière, et false sinon.

Nous allons ajouter une nouvelle méthode à notre classe EmailValidator pour effectuer cette validation.

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

2. Ajoutez la méthode suivante à l'intérieur de la classe EmailValidator, mais en dehors de la méthode main :

   public static boolean isValidEmail(String email) {
       return Pattern.matches(EMAIL_REGEX, email);
   }

   Examinons cette nouvelle méthode :

   • public static boolean isValidEmail(String email) : Cela déclare une nouvelle méthode nommée isValidEmail.
     • public : Signifie que cette méthode peut être accédée depuis l'extérieur de la classe.
     • static : Signifie que cette méthode appartient à la classe EmailValidator elle - même, et non à un objet spécifique de la classe. Nous pouvons l'appeler directement en utilisant le nom de la classe (par exemple, EmailValidator.isValidEmail(...)).
     • boolean : Indique que cette méthode retournera une valeur booléenne (true ou false).
     • (String email) : Spécifie que la méthode prend un argument, une String nommée email, qui est l'adresse e - mail que nous voulons valider.
   • return Pattern.matches(EMAIL_REGEX, email); : C'est le cœur de la méthode. Elle appelle la méthode Pattern.matches(), en passant notre EMAIL_REGEX et la chaîne d'entrée email. Le résultat de cette correspondance (true ou false) est ensuite retourné par notre méthode isValidEmail.

3. Maintenant, modifions la méthode main pour utiliser notre nouvelle méthode isValidEmail. Remplacez la méthode main existante par le code suivant :

   public static void main(String[] args) {
       String testEmail = "[email protected]";
       boolean isValid = isValidEmail(testEmail);
   
       if (isValid) {
           System.out.println(testEmail + " is a valid email address.");
       } else {
           System.out.println(testEmail + " is not a valid email address.");
       }
   }

   Dans cette méthode main mise à jour :

   • String testEmail = "[email protected]"; : Nous définissons une adresse e - mail d'exemple à tester.
   • boolean isValid = isValidEmail(testEmail); : Nous appelons notre méthode isValidEmail avec testEmail et stockons la valeur booléenne retournée dans la variable isValid.
   • Le bloc if et else vérifie la valeur de isValid et affiche un message indiquant si l'e - mail est valide ou non.

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

5. Maintenant, compilons notre programme mis à jour. Ouvrez le terminal en bas du WebIDE et assurez - vous que vous êtes dans le répertoire ~/project. Exécutez la commande suivante :

   javac EmailValidator.java

   S'il n'y a pas d'erreurs, la compilation a réussi.

6. Enfin, exécutez le programme compilé en utilisant la commande java :

   java EmailValidator

   Vous devriez voir un résultat indiquant si l'e - mail de test est valide selon notre motif d'expression régulière.

   [email protected] is a valid email address.

Vous avez maintenant utilisé avec succès la méthode Pattern.matches() pour valider une adresse e - mail en utilisant le motif d'expression régulière que vous avez défini. Dans l'étape suivante, nous testerons avec différentes adresses e - mail valides et invalides.

Tester avec des e-mails valides et invalides

Dans cette étape finale, nous allons tester notre EmailValidator avec quelques exemples d'adresses e - mail valides et invalides pour voir comment notre motif d'expression régulière et la méthode Pattern.matches() les gèrent. Cela nous aidera à comprendre le comportement de notre logique de validation.

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

2. Modifiez la méthode main pour tester plusieurs adresses e - mail. Remplacez la méthode main actuelle par le code suivant :

   public static void main(String[] args) {
       String[] testEmails = {
           "[email protected]",       // Valid
           "[email protected]", // Valid
           "invalid-email",                // Invalid (missing @)
           "invalid@domain",               // Invalid (missing top-level domain)
           "invalid@domain.",              // Invalid (missing top-level domain)
           "[email protected]",             // Invalid (top-level domain too short)
           "[email protected]",      // Invalid (top-level domain too long)
           "@domain.com",                  // Invalid (missing username)
           "[email protected]"                     // Invalid (missing domain name)
       };
   
       for (String email : testEmails) {
           boolean isValid = isValidEmail(email);
   
           if (isValid) {
               System.out.println(email + " is a valid email address.");
           } else {
               System.out.println(email + " is not a valid email address.");
           }
       }
   }

   Dans cette méthode main mise à jour :

   • Nous créons un tableau de chaînes de caractères appelé testEmails contenant diverses adresses e - mail, y compris des adresses valides et des adresses intentionnellement invalides.
   • Nous utilisons une boucle for pour parcourir chaque adresse e - mail dans le tableau testEmails.
   • À l'intérieur de la boucle, pour chaque email, nous appelons notre méthode isValidEmail et affichons le résultat, tout comme nous l'avons fait dans l'étape précédente.

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

4. Compilez le programme modifié dans le terminal :

   javac EmailValidator.java

   Assurez - vous qu'il n'y a pas d'erreurs de compilation.

5. Exécutez le programme compilé :

   java EmailValidator

   Observez le résultat. Vous devriez voir une ligne pour chaque adresse e - mail dans le tableau testEmails, indiquant si notre validateur la considère comme valide ou non en fonction du motif d'expression régulière.

   [email protected] is a valid email address.
   [email protected] is a valid email address.
   invalid-email is not a valid email address.
   invalid@domain is not a valid email address.
   invalid@domain. is not a valid email address.
   [email protected] is not a valid email address.
   [email protected] is not a valid email address.
   @domain.com is not a valid email address.
   [email protected] is not a valid email address.

En testant avec différentes entrées, vous pouvez voir comment le motif d'expression régulière et la méthode Pattern.matches() fonctionnent ensemble pour valider les adresses e - mail. N'oubliez pas que bien que cette expression régulière couvre de nombreux cas courants, valider tous les formats d'e - mail possibles selon des normes strictes peut être beaucoup plus complexe.

Vous avez maintenant implémenté et testé avec succès un mécanisme de validation d'e - mail de base en utilisant les capacités d'expressions régulières de Java.

Résumé

Dans ce laboratoire (lab), nous avons commencé par configurer notre environnement Java et créé un nouveau fichier EmailValidator.java. Nous avons ensuite défini un motif d'expression régulière (EMAIL_REGEX) spécialement conçu pour valider les adresses e - mail. Ce motif, stocké sous forme de chaîne de caractères constante, utilise la classe java.util.regex.Pattern de Java pour permettre des capacités puissantes de correspondance de chaînes de caractères. Cette étape initiale jette les bases pour l'implémentation de la logique de validation d'e - mail dans les étapes suivantes.