Expresiones regulares en Java

Alex Jimenez
Alex Jimenez
Nov 9, 2024

¿Te suena raro eso de “expresiones regulares”? ¿Te intimida ver símbolos como ’.*’, ‘\d’ o ’[^a-z]’ en un código?

No estás solo. Las expresiones regulares (o regex) tienen fama de ser confusas… pero también son una herramienta poderosísima.

En este artículo vamos a ver cómo funcionan las expresiones regulares en Java, para qué sirven, y cómo puedes usarlas paso a paso sin volverte loco. Spoiler: al final vas a querer usarlas todo el tiempo.

¿Qué son las expresiones regulares?

Una expresión regular es una secuencia de caracteres que define un patrón de búsqueda.
Se utilizan para:

  • Validar entradas (como correos electrónicos o contraseñas)
  • Buscar coincidencias en textos
  • Reemplazar cadenas de texto de forma dinámica

En Java, están integradas en la librería estándar desde hace años y son bastante potentes.

expresiones regulares en java

¿Para qué sirven las expresiones regulares en Java?

Aquí algunos casos comunes:

  • Validar un número de teléfono
  • Comprobar si una contraseña cumple requisitos
  • Extraer datos de un texto (como fechas, emails, códigos)
  • Reemplazar caracteres no deseados
  • Dividir cadenas de forma más avanzada que con split()

Si alguna vez has hecho ‘if(nombre.endsWith(“.com”))’, espera a ver lo que puedes hacer con un par de símbolos en regex.

Clases principales que usa Java para regex

Java utiliza principalmente dos clases del paquete ‘java.util.regex’:

  • ‘Pattern’: compila la expresión regular.
  • ‘Matcher’: compara la expresión contra un texto.

También puedes usar métodos más simples desde la clase ‘String’, como ‘matches()’, ‘split()’ y ‘replaceAll()’.

Primer ejemplo: validar un email

String correo = "usuario@email.com";
boolean esValido = correo.matches("^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$");

System.out.println(esValido); // true

¿Qué significa esa expresión?

  • ’^’: inicio de línea
  • ’[\w.-]+’: letras, números, guiones o puntos (usuario)
  • ’@’: símbolo obligatorio
  • ’[\w.-]+’: parte del dominio
  • ’\.’: punto
  • [a-zA-Z]{2,}: mínimo 2 letras para el dominio (com, org, net…)
  • ’$’: final de línea

Sí, puede parecer encriptado… pero ¡es muy preciso!

Usando Pattern y Matcher

Veamos cómo se hace con las clases adecuadas:

import java.util.regex.*;

public class RegexEjemplo {
    public static void main(String[] args) {
        String texto = "Mi número es 503-7123-4567";

        Pattern patron = Pattern.compile("\\d{3}-\\d{4}-\\d{4}");
        Matcher matcher = patron.matcher(texto);

        if (matcher.find()) {
            System.out.println("Número encontrado: " + matcher.group());
        } else {
            System.out.println("No se encontró un número");
        }
    }
}
 Número encontrado: 503-7123-4567

Componentes comunes de una expresión regular

Aquí tienes una mini guía de los símbolos más usados:

SímboloSignificadoEjemplo
.Cualquier carácter excepto salto de líneaa.b (atb, acb)
*Cero o más repeticioneslo*l (ll, lol, loool)
+Una o más repeticioneslo+l (lol, loool)
?Opcional (cero o una vez)colou?r (color, colour)
\dDígito (0-9)\d+ (123, 42)
\wLetra o número (a-z, A-Z, 0-9, _)\w+ (usuario1)
\sEspacio en blanco\s+ (tab, espacio)
[...]Conjunto de caracteres[aeiou] (a, e, i…)
[^...]Excluye caracteres del conjunto[^0-9] (todo menos números)
^Inicio de línea^Hola (debe empezar con Hola)
$Fin de líneamundo$ (debe terminar en mundo)

Validando contraseñas en Java

Digamos que quieres validar que una contraseña tenga al menos:

  • 8 caracteres
  • una mayúscula
  • una minúscula
  • un número
String password = "Java1234";
String regex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$";

boolean esFuerte = password.matches(regex);
System.out.println("¿Es una contraseña fuerte? " + esFuerte);

¿Qué hace esa expresión?

  • (?=.*[a-z]) → al menos una minúscula
  • (?=.*[A-Z]) → al menos una mayúscula
  • (?=.*\d) → al menos un número
  • .8 → mínimo 8 caracteres

Esto es muy útil para validar formularios antes de enviar los datos al servidor.

Reemplazo con replaceAll()

También puedes usar regex para reemplazar partes de un texto fácilmente:

String frase = "Hola123 Mundo456";
String limpia = frase.replaceAll("\\d", ""); // quita los números

System.out.println(limpia); // Hola Mundo

¿Y si quieres quitar solo los caracteres no alfabéticos?

String resultado = frase.replaceAll("[^a-zA-Z ]", "");
System.out.println(resultado); // Hola Mundo

Dividir texto con split()

Olvídate de dividir solo por comas. Con regex puedes dividir usando varios delimitadores:

String datos = "uno,dos; tres:cuatro";
String[] partes = datos.split("[,;:]");

for (String parte : partes) {
    System.out.println(parte.trim());
}

Consejos para trabajar con regex sin volverte loco

  • Usa un sitio como regex101.com para probar tus expresiones con ejemplos en vivo
  • Comienza simple y luego añade condiciones más complejas
  • Usa Pattern.CASE_INSENSITIVE si no quieres distinguir entre mayúsculas y minúsculas
  • Si ves muchos \ en Java, es normal. Java usa \ como carácter de escape, por eso necesitas escribir \d en lugar de \d

¿Vale la pena aprender expresiones regulares?

Totalmente. Aprender expresiones regulares:

  • Te ahorra tiempo en tareas de búsqueda y validación
  • Hace tu código más limpio y poderoso
  • Te da herramientas para trabajar con texto como un ninja

Puede que al principio parezcan jeroglíficos, pero con práctica verás que son un súper poder en tu caja de herramientas como programador.

En resumen

Las expresiones regulares en Java pueden parecer intimidantes al principio, pero son una forma eficiente y poderosa de:

  • Validar entradas
  • Buscar patrones en textos
  • Limpiar, dividir y transformar cadenas

Con práctica y ejemplos reales, se vuelven una herramienta imprescindible en tu día a día como desarrollador Java.

¿Listo para dominar el arte de los patrones?

Artículos relacionados