Expresiones regulares en Java con ejemplos: guía completa

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

```html

Expresiones regulares en Java con ejemplos

Las expresiones regulares (regex) son una herramienta poderosa para buscar, extraer y reemplazar texto según un patrón. En Java, el trabajo con expresiones regulares 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 de las expresiones regulares, los métodos para trabajar con ellas y proporcionaremos ejemplos prácticos en Java.

1. Fundamentos de la sintaxis de expresiones regulares

Una expresión regular define un patrón para buscar cadenas. Aquí están las construcciones básicas:

. — cualquier carácter (excepto salto de línea).
\\d — dígito (0-9).
\\w — letra, dígito o guión bajo (alfabeto latino).
\\s — carácter de espacio en blanco (espacio, tabulación, salto de línea).
[abc] — uno de los caracteres a, b o c.
[^abc] — cualquier carácter excepto a, b, c.
* — cero o más repeticiones.
+ — una o más repeticiones.
? — cero o una repetición.
{n,m} — de n a m repeticiones.
^ — inicio de la cadena.
$ — final de la cadena.
| — O lógico.
() — grupo de captura.

Escapado en Java: en los literales de cadena de Java, la barra invertida \\ es un carácter de escape. Para pasar, por ejemplo, \\d a regex, debes escribir "\\\\d". Para un punto — "\\\\.".

2. Clases Pattern y Matcher

El trabajo con expresiones regulares en Java comienza con la compilación del patrón:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexExample {
    public static void main(String[] args) {
        // Compilamos el patrón
        Pattern pattern = Pattern.compile("\\\\d+");
        // Creamos un Matcher para la cadena
        Matcher matcher = pattern.matcher("Precio: 150 rublos, descuento 20%");
        
        // Búsqueda de todas las coincidencias
        while (matcher.find()) {
            System.out.println("Encontrado: " + matcher.group());
        }
    }
}

Salida:

Encontrado: 150
Encontrado: 20

Métodos principales de Matcher:

find() — busca la siguiente coincidencia (se puede llamar varias veces).
matches() — verifica si toda la cadena coincide con el patrón (requiere coincidencia completa).
lookingAt() — verifica si la cadena comienza con el patrón.
group() — devuelve la subcadena encontrada (o un grupo específico).
groupCount() — número de grupos de captura.

3. Ejemplos prácticos

3.1. Validación de dirección de email

Verificamos si la cadena es un email válido (versión simplificada):

public class EmailValidator {
    public static boolean isValidEmail(String email) {
        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        return matcher.matches();
    }

    public static void main(String[] args) {
        System.out.println(isValidEmail("test@example.com")); // true
        System.out.println(isValidEmail("invalid-email"));    // false
    }
}

Explicación del patrón:

^[a-zA-Z0-9._%+-]+ — parte local (letras, dígitos, puntos, guiones bajos, etc.).
@ — símbolo @.
[a-zA-Z0-9.-]+ — dominio (letras, dígitos, puntos, guiones).
\\\\.[a-zA-Z]{2,}$ — punto y dominio de nivel superior (al menos 2 caracteres).