Expresiones regulares en Java con ejemplos: en la práctica

Expresiones regulares en Java: de la teoría a la práctica

Las expresiones regulares (regex) son una herramienta poderosa para buscar, reemplazar y validar texto. En Java, el trabajo con ellas se implementa a través del paquete java.util.regex, que incluye dos clases principales: Pattern (patrón) y Matcher (comparador). En este artículo analizaremos la sintaxis, los métodos clave y consolidaremos los conocimientos con ejemplos de código reales.

El material será útil tanto para principiantes que recién se familiarizan con Java, como para desarrolladores experimentados que deseen refrescar sus conocimientos. Todos los ejemplos se pueden ejecutar directamente en su IDE.

1. Fundamentos del trabajo con Pattern y Matcher

Cualquier trabajo con regex en Java comienza con la compilación del patrón mediante Pattern.compile(). Después, se crea un objeto Matcher que aplica el patrón a la cadena.

Veamos un ejemplo sencillo: buscar todos los dígitos en un texto.

import java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic class RegexDemo {\n    public static void main(String[] args) {\n        String text = "Java versión 21 se lanzó en el año 2023";\n        String regex = "\\\\d+"; // uno o más dígitos\n\n        Pattern pattern = Pattern.compile(regex);\n        Matcher matcher = pattern.matcher(text);\n\n        while (matcher.find()) {\n            System.out.println("Encontrado: " + matcher.group());\n        }\n    }\n}

Salida del programa:

Encontrado: 21\nEncontrado: 2023

Observe la doble barra invertida \\\\d — en Java, el literal de cadena requiere escapar la barra invertida. Si en regex se necesita especificar \\d, en el código escribimos \\\\d.

2. Sintaxis de las expresiones regulares: metacaracteres y cuantificadores

Para usar regex de manera efectiva, es importante recordar los metacaracteres principales:

\n
• . — cualquier carácter (excepto salto de línea);
\n
• \\\\d — dígito (equivalente a [0-9]);
\n
• \\\\w — letra, dígito o guion bajo ([a-zA-Z0-9_]);
\n
• \\\\s — carácter de espacio en blanco;
\n
• ^ — inicio de la cadena;
\n
• $ — final de la cadena.
\n

Los cuantificadores controlan la cantidad de repeticiones:

\n
• + — una o más veces;
\n
• * — cero o más veces;
\n
• ? — cero o una vez;
\n
• {n} — exactamente n veces;
\n
• {n,m} — de n a m veces.
\n

Ejemplo: busquemos todas las palabras compuestas solo por letras latinas, de 3 a 5 caracteres de longitud.

String text = "Java regex example for beginners";\nString regex = "\\\\b[a-zA-Z]{3,5}\\\\b";\n\nPattern pattern = Pattern.compile(regex);\nMatcher matcher = pattern.matcher(text);\n\nwhile (matcher.find()) {\n    System.out.println(matcher.group());\n}\n// Salida: Java, regex, for

El límite de palabra \\\\b evita coincidencias parciales (por ejemplo, "Java" no será parte de "JavaScript").

3. Ejemplos prácticos: validación y extracción de datos

Pasemos a tareas que se encuentran a menudo en el desarrollo real.

3.1. Validación de dirección de correo electrónico

Verificación simple: presencia del símbolo "@" y dominio.

public static boolean isValidEmail(String email) {\n    String regex = "^[\\\\w.-]+@[\\\\w.-]+\\\\.\\\\w{2,}$";\n    return Pattern.matches(regex, email);\n}\n\npublic static void main(String[] args) {\n    System.out.println(isValidEmail("user@example.com")); // true\n    System.out.println(isValidEmail("invalid-email"));    // false\n}

El método Pattern.matches() verifica automáticamente toda la cadena (equivalente a matcher.matches()).

3.2. Extracción de números de teléfono

Supongamos que en el texto aparecen números en el formato "+7 (999) 123-45-67".

String text = "Contacto: +