Cómo verificar si una cadena coincide con un formato de número de teléfono en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena coincide con el formato de un número de teléfono en Java utilizando Expresiones Regulares (Regex). Comenzaremos creando un patrón Regex diseñado específicamente para coincidir con los formatos comunes de números de teléfono.

A continuación, validarás una cadena de número de teléfono dada contra el patrón Regex creado utilizando la clase Matcher de Java. Finalmente, explorarás cómo manejar y coincidir diferentes variaciones de formatos de números de teléfono ajustando el patrón Regex.

Skills Graph

Crear una Expresión Regular (Regex) para Números de Teléfono

En este paso, aprenderemos sobre las Expresiones Regulares (Regex) y cómo crear una para coincidir con números de teléfono. Las Regex son una herramienta poderosa utilizada para la coincidencia de patrones en cadenas de texto. Es como un lenguaje especial para describir patrones de texto.

¿Por qué necesitamos Regex para números de teléfono? Los números de teléfono pueden tener muchos formatos (por ejemplo, 123-456-7890, (123) 456-7890, 123.456.7890). Las Regex nos permiten definir un patrón que coincida con todas estas variaciones.

Vamos a crear un simple programa en Java que utilice Regex para verificar si una cadena parece ser un número de teléfono.

1. Abre el archivo HelloJava.java en el editor WebIDE si no está abierto.

2. Reemplaza todo el contenido del archivo con el siguiente código:

   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 cadena a verificar
           String regex = "\\d{3}-\\d{3}-\\d{4}"; // El patrón Regex
   
           Pattern pattern = Pattern.compile(regex);
           Matcher matcher = pattern.matcher(phoneNumber);
   
           boolean isMatch = matcher.matches();
   
           if (isMatch) {
               System.out.println(phoneNumber + " es un formato de número de teléfono válido.");
           } else {
               System.out.println(phoneNumber + " no es un formato de número de teléfono válido.");
           }
       }
   }

   Veamos las nuevas partes de este código:

   • import java.util.regex.Matcher; y import java.util.regex.Pattern;: Estas líneas importan las clases necesarias para trabajar con Regex en Java.
   • String phoneNumber = "123-456-7890";: Esta es la cadena que queremos probar.
   • String regex = "\\d{3}-\\d{3}-\\d{4}";: Este es nuestro primer patrón Regex. Analicémoslo:
     • \\d: Coincide con cualquier dígito (0-9). Usamos \\ porque \ es un carácter especial en las cadenas de Java, por lo que debemos escaparlo.
     • {3}: Coincide con el elemento anterior exactamente 3 veces.
     • -: Coincide literalmente con el carácter guion.
     • Entonces, \\d{3}-\\d{3}-\\d{4} coincide con tres dígitos, seguidos de un guion, seguidos de tres dígitos, seguidos de un guion, seguidos de cuatro dígitos.
   • Pattern pattern = Pattern.compile(regex);: Esto compila la cadena Regex en un objeto Pattern, que es más eficiente para coincidencias repetidas.
   • Matcher matcher = pattern.matcher(phoneNumber);: Esto crea un objeto Matcher que realizará la operación de coincidencia en nuestra cadena phoneNumber utilizando el pattern compilado.
   • boolean isMatch = matcher.matches();: Esto intenta coincidir la cadena de entrada completa (phoneNumber) con el patrón. Devuelve true si toda la cadena coincide, y false en caso contrario.
   • El bloque if y else simplemente imprime un mensaje según si la cadena coincide con el patrón.

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa en la Terminal:

   javac HelloJava.java

   Si no hay errores, se creará un archivo HelloJava.class.

5. Ejecuta el programa compilado:

   java HelloJava

   Deberías ver la salida que indica que "123-456-7890" es un formato de número de teléfono válido según nuestra simple Regex.

En este paso, has aprendido los conceptos básicos de usar Regex en Java y has creado un simple patrón para coincidir con un formato específico de número de teléfono. En los siguientes pasos, haremos nuestra Regex más flexible para manejar diferentes formatos.

Validar un Número de Teléfono con Matcher

En el paso anterior, creamos un simple patrón Regex y usamos el método matches() de la clase Matcher para verificar si una cadena completa coincidía con el patrón. En este paso, exploraremos más a fondo la clase Matcher y veremos cómo funciona.

La clase Matcher es el motor que realiza las operaciones de coincidencia. Se crea a partir de un objeto Pattern y se utiliza para encontrar ocurrencias del patrón dentro de una cadena de entrada.

Modifiquemos nuestro programa para probar una cadena diferente y veamos cómo se comporta el método matches().

1. Abre el archivo HelloJava.java en el editor WebIDE.

2. Cambia la cadena phoneNumber a algo que no coincida exactamente con nuestro patrón actual \\d{3}-\\d{3}-\\d{4}. Por ejemplo, cambia la línea:

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

   a:

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

3. Guarda el archivo (Ctrl+S o Cmd+S).

4. Compila el programa modificado en la Terminal:

   javac HelloJava.java

5. Ejecuta el programa compilado:

   java HelloJava

   Esta vez, la salida debería ser:

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

   ¿Por qué sucedió esto? Porque el método matches() intenta coincidir la cadena de entrada completa con el patrón. Dado que nuestra cadena de entrada contiene más que solo el patrón del número de teléfono, matches() devuelve false.

   Si quisiéramos encontrar si el patrón existe en cualquier parte dentro de la cadena, usaríamos un método diferente, como find(), que exploraremos más adelante. Por ahora, nos estamos enfocando en validar si la cadena completa se ajusta a un formato específico usando matches().

   Entender la diferencia entre matches() y find() es crucial cuando se trabaja con Regex en Java. matches() es para la validación estricta de toda la cadena, mientras que find() es para buscar el patrón dentro de una cadena más grande.

En este paso, has visto cómo funciona el método matches() de la clase Matcher y por qué es importante entender su comportamiento al validar formatos de cadenas.

Manejar Diferentes Formatos de Número de Teléfono

En el mundo real, los números de teléfono no siempre siguen exactamente el formato XXX-XXX-XXXX. Pueden usar puntos (.), espacios ( ) o incluso paréntesis (()). En este paso, modificaremos nuestro patrón Regex para manejar algunas de estas variaciones.

Introduciremos algunos conceptos adicionales de Regex para hacer nuestro patrón más flexible:

• ?: Hace que el elemento anterior sea opcional (0 o 1 vez).
• *: Coincide con el elemento anterior cero o más veces.
• +: Coincide con el elemento anterior una o más veces.
• []: Define un conjunto de caracteres. Coincide con cualquier carácter individual dentro de los corchetes.
• |: Actúa como un operador OR. Coincide con el patrón antes o después del |.

Actualicemos nuestro archivo HelloJava.java para usar un patrón Regex más flexible.

1. Abre el archivo HelloJava.java en el editor WebIDE.

2. Cambia la cadena regex a lo siguiente:

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

   Analicemos este nuevo patrón:

   • \\(?: Coincide con un paréntesis de apertura opcional (. Necesitamos \\ para escapar el significado especial de ( en Regex, y ? lo hace opcional.
   • \\d{3}: Coincide exactamente con tres dígitos.
   • \\)?: Coincide con un paréntesis de cierre opcional ).
   • [-.\\s]?: Este es un conjunto de caracteres [] que coincide con un guion (-), un punto (.), o un carácter de espacio en blanco (\\s). El ? hace que este separador sea opcional.
   • \\d{3}: Coincide exactamente con tres dígitos.
   • [-.\\s]?: Coincide con un separador opcional de guion, punto o espacio en blanco nuevamente.
   • \\d{4}: Coincide exactamente con cuatro dígitos.

   Este patrón ahora puede coincidir con formatos como 123-456-7890, (123) 456-7890, 123.456.7890, 123 456 7890 e incluso 1234567890 (sin ningún separador).

3. Ahora, probemos este nuevo patrón con diferentes formatos de número de teléfono. Reemplaza la cadena phoneNumber con algunos ejemplos diferentes:

   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.");
               }
           }
       }
   }

   Hemos introducido un arreglo de String llamado phoneNumbers para probar fácilmente múltiples entradas y un bucle for para iterar sobre ellas.

4. Guarda el archivo (Ctrl+S o Cmd+S).

5. Compila el programa en la Terminal:

   javac HelloJava.java

6. Ejecuta el programa compilado:

   java HelloJava

   Deberías ver una salida similar a esta, que muestra qué cadenas coinciden con el patrón:

   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.

Ahora has creado un patrón Regex más robusto que puede manejar varios formatos comunes de números de teléfono. Esto demuestra el poder y la flexibilidad de las Regex para validar y analizar cadenas.

Resumen

En este laboratorio, aprendimos cómo verificar si una cadena coincide con un formato de número de teléfono en Java utilizando Expresiones Regulares (Regex). Comenzamos por entender el concepto de Regex y su importancia para la coincidencia de patrones, especialmente para manejar varios formatos de números de teléfono. Luego, creamos un simple programa en Java que utiliza el paquete java.util.regex.

El primer paso consistió en crear un patrón Regex básico \\d{3}-\\d{3}-\\d{4} para coincidir con el formato "XXX-XXX-XXXX". Utilizamos Pattern.compile() para compilar la expresión regular en un objeto Pattern y Pattern.matcher() para crear un objeto Matcher para la cadena de entrada. Finalmente, utilizamos matcher.matches() para verificar si la cadena completa coincidía con el patrón y mostramos el resultado. Esto sentó las bases para validar números de teléfono utilizando Regex en Java.