Cómo comprobar si una cadena coincide con un formato de correo electrónico en Java

Introducción

En este laboratorio, aprenderás cómo validar si una cadena dada coincide con un formato de correo electrónico estándar en Java utilizando expresiones regulares. Definiremos un patrón de expresión regular adecuado, utilizaremos el método Pattern.matches() para la validación y probaremos nuestra implementación con varias direcciones de correo electrónico válidas e inválidas para asegurarnos de que funcione correctamente. Este ejercicio práctico proporcionará experiencia práctica con las capacidades de expresiones regulares de Java para la coincidencia de patrones de cadenas.

Definir el patrón de expresión regular para correos electrónicos

En este paso, comenzaremos definiendo el patrón de expresión regular que utilizaremos para validar direcciones de correo electrónico. Las expresiones regulares, a menudo abreviadas como "regex" o "regexp", son secuencias de caracteres que definen un patrón de búsqueda. Son extremadamente poderosas para la coincidencia de patrones y la manipulación de cadenas.

Para la validación de correos electrónicos, un patrón de expresión regular nos ayuda a verificar si una cadena dada sigue el formato estándar de una dirección de correo electrónico (por ejemplo, username@domain.com). Si bien una expresión regular perfecta para todas las posibles direcciones de correo electrónico válidas es muy compleja, podemos definir un patrón que cubra la mayoría de los formatos comunes y válidos.

Crearemos un nuevo archivo Java para contener nuestro código.

Abre el WebIDE si no está abierto. Por defecto, deberías estar en el directorio ~/project.
En el Explorador de archivos de la izquierda, haz clic derecho en el espacio vacío y selecciona "Nuevo archivo". Nombrar el archivo EmailValidator.java.
Abre el archivo EmailValidator.java en el editor haciendo clic en él en el Explorador de archivos.
Ahora, agreguemos la estructura básica de nuestra clase Java y definamos el patrón de expresión regular. Copia y pega el siguiente código en el archivo 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
    }
}
```
Echemos un vistazo breve a las nuevas partes:
- import java.util.regex.Pattern;: Esta línea importa la clase Pattern, que es parte del soporte integrado de Java para expresiones regulares.
- private static final String EMAIL_REGEX = "...";: Esta línea declara una variable constante llamada EMAIL_REGEX y le asigna nuestro patrón de expresión regular.
  - ^: Coincide con el inicio de la cadena.
  - [a-zA-Z0-9_+&*-]+: Coincide con uno o más caracteres alfanuméricos o _, +, &, *, -. Esto es para la parte del nombre de usuario.
  - (?:\\.[a-zA-Z0-9_+&*-]+)*: Coincide con cero o más ocurrencias de un punto seguido de más caracteres de nombre de usuario. Esto permite puntos en el nombre de usuario (por ejemplo, first.last).
  - @: Coincide con el símbolo literal "@".
  - (?:[a-zA-Z0-9-]+\\.)+: Coincide con una o más ocurrencias de caracteres alfanuméricos o - seguidos de un punto. Esto es para el nombre de dominio (por ejemplo, domain.).
  - [a-zA-Z]{2,7}: Coincide con 2 a 7 caracteres alfabéticos para el dominio de nivel superior (por ejemplo, com, org, códigos de país).
  - $: Coincide con el final de la cadena.
No te preocupes si el patrón de expresión regular parece complicado. Comprender cada detalle de los patrones de expresiones regulares complejas lleva tiempo y práctica. Por ahora, concéntrate en el hecho de que esta cadena define la regla de cómo debe ser una dirección de correo electrónico válida.
Guarda el archivo EmailValidator.java (Ctrl+S o Cmd+S).

Ahora has creado con éxito el archivo Java y definido el patrón de expresión regular para la validación de correos electrónicos. En el siguiente paso, utilizaremos este patrón para validar direcciones de correo electrónico reales.

Usar Pattern.matches() para validar correos electrónicos

En este paso, aprenderemos cómo utilizar el método Pattern.matches() en Java para verificar si una cadena dada coincide con nuestro patrón de expresión regular para correos electrónicos definido. El método Pattern.matches(regex, input) es una forma conveniente de realizar una coincidencia simple de una cadena de entrada completa con una expresión regular. Devuelve true si la cadena de entrada completa coincide con la expresión regular, y false en caso contrario.

Agregaremos un nuevo método a nuestra clase EmailValidator para realizar esta validación.

Abre el archivo EmailValidator.java en el editor del WebIDE si no está abierto.
Agrega el siguiente método dentro de la clase EmailValidator, pero fuera del método main:
```
public static boolean isValidEmail(String email) {
    return Pattern.matches(EMAIL_REGEX, email);
}
```
Echemos un vistazo a este nuevo método:
- public static boolean isValidEmail(String email): Esto declara un nuevo método llamado isValidEmail.
  - public: Significa que este método se puede acceder desde fuera de la clase.
  - static: Significa que este método pertenece a la clase EmailValidator en sí, no a un objeto específico de la clase. Podemos llamarlo directamente utilizando el nombre de la clase (por ejemplo, EmailValidator.isValidEmail(...)).
  - boolean: Indica que este método devolverá un valor booleano (true o false).
  - (String email): Especifica que el método toma un argumento, una String llamada email, que es la dirección de correo electrónico que queremos validar.
- return Pattern.matches(EMAIL_REGEX, email);: Este es el núcleo del método. Llama al método Pattern.matches(), pasando nuestra EMAIL_REGEX y la cadena de entrada email. El resultado de esta coincidencia (true o false) es luego devuelto por nuestro método isValidEmail.
Ahora, modifiquemos el método main para utilizar nuestro nuevo método isValidEmail. Reemplaza el método main existente con el siguiente código:
```
public static void main(String[] args) {
    String testEmail = "test.email@example.com";
    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.");
    }
}
```
En este método main actualizado:
- String testEmail = "test.email@example.com";: Definimos una dirección de correo electrónico de muestra para probar.
- boolean isValid = isValidEmail(testEmail);: Llamamos a nuestro método isValidEmail con el testEmail y almacenamos el valor booleano devuelto en la variable isValid.
- El bloque if y else verifica el valor de isValid e imprime un mensaje que indica si el correo electrónico es válido o no.
Guarda el archivo EmailValidator.java (Ctrl+S o Cmd+S).
Ahora, compilaremos nuestro programa actualizado. Abre la Terminal en la parte inferior del WebIDE y asegúrate de que estés en el directorio ~/project. Ejecuta el siguiente comando:
```
javac EmailValidator.java
```
Si no hay errores, la compilación fue exitosa.
Finalmente, ejecuta el programa compilado utilizando el comando java:
```
java EmailValidator
```
Deberías ver una salida que indique si el correo electrónico de prueba es válido según nuestro patrón de expresión regular.
```
test.email@example.com is a valid email address.
```

Ahora has utilizado con éxito el método Pattern.matches() para validar una dirección de correo electrónico utilizando tu patrón de expresión regular definido. En el siguiente paso, probaremos con diferentes direcciones de correo electrónico válidas e inválidas.

Probar con correos electrónicos válidos e inválidos

En este último paso, probaremos nuestra clase EmailValidator con algunos ejemplos de direcciones de correo electrónico tanto válidas como inválidas para ver cómo nuestro patrón de expresión regular y el método Pattern.matches() las manejan. Esto nos ayudará a entender el comportamiento de nuestra lógica de validación.

Abre el archivo EmailValidator.java en el editor del WebIDE.

Modifica el método main para probar múltiples direcciones de correo electrónico. Reemplaza el método main actual con el siguiente código:

public static void main(String[] args) {
    String[] testEmails = {
        "test.email@example.com",       // Valid
        "another_test+alias@sub.domain.co.uk", // Valid
        "invalid-email",                // Invalid (missing @)
        "invalid@domain",               // Invalid (missing top-level domain)
        "invalid@domain.",              // Invalid (missing top-level domain)
        "invalid@domain.c",             // Invalid (top-level domain too short)
        "invalid@domain.abcdefgh",      // Invalid (top-level domain too long)
        "@domain.com",                  // Invalid (missing username)
        "test@.com"                     // 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.");
        }
    }
}

En este método main actualizado:

Creamos un array de cadenas llamado testEmails que contiene varias direcciones de correo electrónico, incluyendo tanto válidas como intencionalmente inválidas.
Usamos un bucle for para iterar a través de cada dirección de correo electrónico en el array testEmails.
Dentro del bucle, para cada email, llamamos a nuestro método isValidEmail e imprimimos el resultado, tal como hicimos en el paso anterior.

Guarda el archivo EmailValidator.java (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac EmailValidator.java
```
Asegúrate de que no haya errores de compilación.

Ejecuta el programa compilado:

java EmailValidator

Observa la salida. Deberías ver una línea para cada dirección de correo electrónico en el array testEmails, indicando si nuestro validador la considera válida o no según el patrón de expresión regular.

test.email@example.com is a valid email address.
another_test+alias@sub.domain.co.uk 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.
invalid@domain.c is not a valid email address.
invalid@domain.abcdefgh is not a valid email address.
@domain.com is not a valid email address.
test@.com is not a valid email address.

Al probar con diferentes entradas, puedes ver cómo el patrón de expresión regular y el método Pattern.matches() trabajan juntos para validar direcciones de correo electrónico. Recuerda que aunque esta expresión regular cubre muchos casos comunes, validar todos los posibles formatos de correo electrónico de acuerdo con estándares estrictos puede ser mucho más complejo.

Ahora has implementado y probado con éxito un mecanismo básico de validación de correos electrónicos utilizando las capacidades de expresiones regulares de Java.

Resumen

En este laboratorio, comenzamos configurando nuestro entorno de Java y creando un nuevo archivo EmailValidator.java. Luego, definimos un patrón de expresión regular (EMAIL_REGEX) específicamente diseñado para validar direcciones de correo electrónico. Este patrón, almacenado como una cadena constante, utiliza la clase java.util.regex.Pattern de Java para habilitar potentes capacidades de coincidencia de cadenas. Este primer paso establece la base para implementar la lógica de validación de correos electrónicos en los pasos posteriores.