No voy a negarte que las expresiones regulares sí son un poco intimidantes. La verdad es como un idioma secreto, lleno de símbolos raros y difíciles de comprender. Yo aprendí a dominarlas porque un día estaba tratando de filtrar correos electrónicos válidos en una aplicación y fue cuando descubrí java.util.regex.Pattern. Me sorprendí al saber que con las expresiones regulares podía crear reglas increíblemente precisas y reutilizables para encontrar patrones en cadenas. Entonces, voy a mostrarte cómo usar esta clase de Java para crear patrones avanzados. No te preocupes porque usaré ejemplos prácticos, acompañados de explicaciones realmente sencillas.

¿Qué encontrarás en este post?

¿Qué es java.util.regex.Pattern?

La clase java.util.regex.Pattern es como un molde para cortar galletas. ¿Los has visto? resulta que tú diseñas el molde (el patrón) una sola vez y ya luego lo usas para darle forma a múltiples galletas que serían las coincidencias en las cadenas.

Entonces, java.util.regex.Pattern es un patrón compilado que transforma una expresión regular en un objeto optimizado para realizar mejores búsquedas en cadenas.

Es muy importante que sepas que la clase Pattern no tiene constructores públicos, así que tendrás que usar el método estático compile si quieres crear un patrón. Ya cuando lo crees ahora sí puedes usarlo con la clase Matcher para buscar coincidencias en un texto.

Te muestro:

Pattern pattern = Pattern.compile("hola");
Matcher matcher = pattern.matcher("hola mundo, hola Java");
while (matcher.find()) {
    System.out.println("Coincidencia encontrada: " + matcher.group());
}

Creando patrones avanzados con java.util.regex.Pattern

Durante los siguientes ejemplos estaré mostrándote cómo puedes crear los patrones avanzados con java.util.regex.Pattern. Presta mucha atención para que te quede fácil de ponerlo en práctica:

Uso de caracteres especiales

Ten en cuenta que los metacaracteres son símbolos que añaden lógica a los patrones. Por ejemplo:

. : Este coincide con cualquier carácter.
\d: Coincide con cualquier dígito.
\w: Coincide con cualquier carácter alfanumérico.

Ejemplo: ¿Cómo harías para encontrar números en un texto? En este código te lo explico:

Pattern pattern = Pattern.compile("\\d+");
Matcher matcher = pattern.matcher("Hay 3 gatos y 12 perros.");
while (matcher.find()) {
    System.out.println("Número encontrado: " + matcher.group());
}

Mira la salida:

Número encontrado: 3
Número encontrado: 12

Clases de caracteres

Algo grandioso y que a mí me gusta mucho es que puedes definir rangos o grupos de caracteres:

[abc]: Coincide con cualquier carácter dentro del grupo.
[a-z]: Coincide con cualquier letra minúscula.
[^abc]: Coincide con cualquier carácter que no esté en el grupo.

Observa cuidadosamente el ejemplo: Encuentra palabras que comiencen con vocales.

Pattern pattern = Pattern.compile("\\b[aeiouAEIOU]\\w*");
Matcher matcher = pattern.matcher("Una casa y un árbol");
while (matcher.find()) {
    System.out.println("Palabra encontrada: " + matcher.group());
}

Esta es la salida:

Palabra encontrada: Una
Palabra encontrada: y

Cuantificadores

Ten en cuenta que los cuantificadores indican cuántas veces debe aparecer un elemento:

? : 0 o 1 vez.
* : 0 o más veces.
+ : 1 o más veces.
{n,m} : Entre n y m veces.

En este ejemplo vas a buscar palabras que contengan al menos dos vocales seguidas.

Pattern pattern = Pattern.compile("\\w*[aeiouAEIOU]{2,}\\w*");
Matcher matcher = pattern.matcher("cooperación, idea, oso, zoológico");
while (matcher.find()) {
    System.out.println("Palabra encontrada: " + matcher.group());
}

La salida te queda así:

Palabra encontrada: cooperación
Palabra encontrada: zoológico

Agrupamientos y referencias

Recuerda que los grupos te permiten capturar partes específicas del texto y reutilizarlas.

Aquí quiero que encuentres las palabras duplicadas consecutivas.

Pattern pattern = Pattern.compile("\\b(\\w+) \\1\\b");
Matcher matcher = pattern.matcher("Este es un ejemplo ejemplo de repetición repetición");
while (matcher.find()) {
    System.out.println("Repetición encontrada: " + matcher.group());
}

Esta sería la salida:

Repetición encontrada: ejemplo ejemplo
Repetición encontrada: repetición repetición

Flags para modificar el comportamiento

También debes entender que puedes usar flags para cambiar cómo se interpreta el patrón. Algunos flags útiles son:

Pattern.CASE_INSENSITIVE: Ignora mayúsculas y minúsculas.
Pattern.MULTILINE: Permite coincidencias en múltiples líneas.
Pattern.DOTALL: Hace que . coincida con saltos de línea.

Te muestro cómo ignorar mayúsculas y minúsculas.

Pattern pattern = Pattern.compile("java", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher("Java es genial. Me encanta JAVA.");
while (matcher.find()) {
    System.out.println("Coincidencia: " + matcher.group());
}