Expresiones regulares

En resumen: Una expresión regular (regex) es un patrón que describe cómo es un texto: con ella compruebas, buscas, reemplazas y divides texto en lugar de escribir muchos ifs.

Problema

Dieciséis líneas para una fecha

El formulario de reservas pide una fecha con la forma dd.mm.aaaa. La compruebas carácter por carácter:

static boolean isDate(String s) {
    if (s.length() != 10) {
        return false;
    }
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (i == 2 || i == 5) {
            if (c != '.') {
                return false;
            }
        } else if (c < '0' || c > '9') {
            return false;
        }
    }
    return true;
}

System.out.println(isDate("05.03.2026"));
System.out.println(isDate("5.3.2026"));
System.out.println(isDate("05/03/2026"));

Salida

true
false
false

Dieciséis líneas, y el método solo comprueba el formato: dos dígitos, un punto, dos dígitos, un punto, cuatro dígitos. Si además quieres aceptar / en lugar del punto, o un día de una sola cifra, añadirás otras tantas líneas. Un número de teléfono, un email o una matrícula te costarán otro método como este cada uno.

La idea

Un patrón en lugar de código

Describes cómo es el texto, y Java hace la comprobación:

static boolean isDate(String s) {
    return s.matches("\\d{2}\\.\\d{2}\\.\\d{4}");
}

System.out.println(isDate("05.03.2026"));
System.out.println(isDate("5.3.2026"));
System.out.println(isDate("05/03/2026"));

Salida

true
false
false

El patrón se lee de izquierda a derecha: \d es un dígito, {2} significa «dos veces», \. es un punto. Un patrón así se llama expresión regular (regular expression, regex).

matches devuelve true si todo el texto encaja con el patrón, del primer carácter al último.

¿Por qué el código dice \\d y no \d? La barra invertida también es especial para la cadena de Java, así que se escribe dos veces. Lo veremos en detalle dentro de un momento. Por ahora, lee \\ en el código como una sola \ en el patrón.

Míralo

Cómo busca el patrón

replaceAll no comprueba todo el texto. Busca los trozos que encajan con el patrón y los reemplaza. Así recorre la línea:

String line = "120 € el 05.03.2026, vence 15.04.2026";
String masked = line.replaceAll("\\d{2}\\.\\d{2}\\.\\d{4}", "[fecha]");
System.out.println(masked);

Paso a paso, en palabras

1. La línea es una secuencia de caracteres, cada uno con su posición.
2. Desde la posición 0: «1» y «2» son dígitos, pero después viene «0» en lugar de un punto. El intento falla.
3. Un intento nuevo desde cada carácter siguiente: «20 », «0 », « €»… todos fallan.
4. Desde la posición 9 encajan las diez partes: la primera coincidencia.
5. La búsqueda sigue después de la coincidencia, desde la coma, y encuentra la segunda.
6. replaceAll reemplaza las dos coincidencias por «[fecha]».

El patrón se prueba desde cada posición, una tras otra. En cuanto una parte no coincide, el intento falla y empieza uno nuevo desde el carácter siguiente. Por eso 120 no pasó: dos dígitos, y después un 0 en lugar de un punto. Cuando encuentra una coincidencia, la búsqueda sigue después de ella.

La idea

Clases de caracteres

Entre corchetes enumeras qué caracteres se permiten en una posición. Una matrícula de coche son una o dos letras, cuatro dígitos y dos letras:

String[] plates = { "CA1234BX", "B7788KK", "CA12345BX", "ca1234bx" };
for (String plate : plates) {
    System.out.println(plate + " " + plate.matches("[A-Z]{1,2}\\d{4}[A-Z]{2}"));
}

Salida

CA1234BX true
B7788KK true
CA12345BX false
ca1234bx false

Patrón	Coincide con un carácter
[ABE]	A, B o E
[0-9], [A-Z]	del rango: un dígito, una letra latina mayúscula
[^0-9]	cualquier cosa excepto un dígito (^ al principio de los corchetes)
\d	un dígito, lo mismo que [0-9]
\s	un espacio, un tabulador, un salto de línea
\w	una letra latina, un dígito o _
.	cualquier carácter (excepto el salto de línea)

Las mayúsculas invierten el significado: \D es «no un dígito», \S es «no un espacio», \W es «no \w».

Cuidado con \w: en Java, por defecto, son solo letras latinas, sin acentos.

System.out.println("Sofia".matches("\\w+"));
System.out.println("Zürich".matches("\\w+"));
System.out.println("Zürich".matches("(?U)\\w+"));
System.out.println("Zürich".matches("[A-Za-zü]+"));

Salida

true
false
true
true

Para un texto con letras como «ü» o «é», enuméralas en la clase, [A-Za-zü], o pon (?U) al principio del patrón: entonces \w conoce las letras de todos los idiomas.

Más precisamente, para curiosos

• [A-Z] es un rango según los códigos de los caracteres. Contiene solo las 26 letras latinas, sin «É», «Ñ» ni «Ü», que están en otro lugar de la tabla. Para un texto en inglés basta con [A-Za-z]. Si también necesitas letras con acento, añádelas: [A-Za-zÉéÑñÜü].
• Las matrículas búlgaras de verdad usan solo 12 letras, las que se ven igual en cirílico y en latino: [ABEKMHOPCTYX].

Pruébalo

El punto

Alguien olvidó la barra invertida delante de los puntos:

¿Qué imprimirá el programa?

String pattern = "\\d{2}.\\d{2}.\\d{4}";
System.out.println("05.03.2026".matches(pattern));
System.out.println("05-03-2026".matches(pattern));
System.out.println("05.03.26".matches(pattern));

Respuesta

true
true
false

true
false
false

false
false
false

Comprobar

La idea

Cuántas veces

Después de un carácter o de una clase dices cuántas veces puede repetirse. Esto es un cuantificador:

Cuantificador	Significa
?	cero o una vez (puede estar o no)
*	cero o más
+	una o más
{4}	exactamente 4
{1,2}	de 1 a 2
{2,}	2 o más

Un número de móvil búlgaro empieza con 0 o +359, después 87, 88 u 89, y 7 dígitos más:

String mobile = "(\\+359|0)8[789]\\d{7}";
System.out.println("0888123456".matches(mobile));
System.out.println("+359877654321".matches(mobile));
System.out.println("0888 123 456".matches(mobile));
System.out.println("088812345".matches(mobile));

Salida

true
true
false
false

| significa «o». Los paréntesis mantienen \+359|0 juntos: sin ellos, la «o» partiría todo el patrón en dos. Los paréntesis hacen más cosas, que veremos en la próxima lección. El + del principio lleva \, porque si no, es un cuantificador.

Un cuantificador también funciona sobre un grupo entero entre paréntesis. Aquí tienes un precio con parte decimal o sin ella:

String price = "\\d+([.,]\\d{1,2})? €";
System.out.println("12 €".matches(price));
System.out.println("12.5 €".matches(price));
System.out.println("12,50 €".matches(price));
System.out.println(".50 €".matches(price));

Salida

true
true
true
false

([.,]\d{1,2})? significa «un punto o una coma y uno o dos dígitos», y todo este bloque puede faltar.

La idea

Dos barras invertidas

El patrón pasa por dos capas. Primero Java lee la cadena entre comillas, después la regex lee el patrón.

En una cadena de Java, \ empieza un carácter especial: \n es un salto de línea, \" es una comilla. \d no es uno de ellos, así que el programa no compila:

String date = "05.03.2026";
System.out.println(date.matches("\d{2}\.\d{2}\.\d{4}"));

Error de compilación

Main.java:4: error: illegal escape character
        System.out.println(date.matches("\d{2}\.\d{2}\.\d{4}"));
                                          ^

Por eso cada \ del patrón se escribe \\ en Java:

String date = "05.03.2026";
System.out.println(date.matches("\\d{2}\\.\\d{2}\\.\\d{4}"));
System.out.println("C:\\Temp".matches("C:\\\\Temp"));

Salida

true
true

Quieres en el patrón	Escribes en Java
\d (un dígito)	"\\d"
\. (un punto de verdad)	"\\."
\\ (una barra invertida de verdad)	"\\\\"

Los caracteres que necesitan \ cuando los quieres tal cual son . * + ? ( ) [ ] { } | ^ $ \.

Pruébalo

Encuentra el error

El programa debería imprimir «12 € y 50 céntimos», pero se detiene así:

Error

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0
  at Main.main(Main.java:5)

Elige la línea con el error.

1String price = "12.50";2String[] parts = price.split(".");3int euros = Integer.parseInt(parts[0]);4int cents = Integer.parseInt(parts[1]);5System.out.println(euros + " € y " + cents + " céntimos");

Comprobar

La idea

Reemplazar y dividir con un patrón

replaceAll y split reciben un patrón. Así limpias y separas un texto que la gente escribe como le da la gana:

String address = "Envío:   calle Mayor 12,    portal B";
System.out.println(address.replaceAll("\\s+", " "));
String[] items = "pan, leche;café  té".split("[,;\\s]+");
System.out.println(items.length + ": " + String.join(" | ", items));
System.out.println("Código SUMMER10, código summer25".replaceAll("(?i)summer\\d+", "***"));

Salida

Envío: calle Mayor 12, portal B
4: pan | leche | café | té
Código ***, código ***

• \s+ es «uno o más espacios»: cada grupo de espacios se convierte en uno solo.
• [,;\s]+ es «comas, puntos y comas o espacios, los que haya»: el separador puede ser cualquiera de ellos.

• (?i) al principio es una bandera (flag): el patrón no distingue entre mayúsculas y minúsculas.

replace (sin All) también reemplaza todas las apariciones, pero busca texto normal, no un patrón. Si no necesitas un patrón, úsalo: no tienes que pensar en puntos ni en barras invertidas.

\b es un límite de palabra: el lugar entre una letra y algo que no es una letra. Con él reemplazas solo palabras completas. Aquí también (?U) es imprescindible para letras como «é»:

String text = "éxito y éxitos";
System.out.println(text.replaceAll("éxito", "triunfo"));
System.out.println(text.replaceAll("\\béxito\\b", "triunfo"));
System.out.println(text.replaceAll("(?U)\\béxito\\b", "triunfo"));

Salida

triunfo y triunfos
éxito y éxitos
triunfo y éxitos

Sin \b, «éxitos» se convierte en «triunfos». Con \b pero sin (?U), Java no ve la «é» como una letra y no reemplaza nada.

Más precisamente, para curiosos

• \B es lo contrario de \b: un lugar dentro de una palabra. "(?U)\\Bé" encuentra la «é» solo cuando no está al principio de una palabra: en «café», pero no en «éxito».
• ^ es el principio del texto, y $ es el final: replaceAll("^0+", "") quita los ceros iniciales. Con matches no los necesitas, porque de todos modos mira todo el texto.
• Las banderas también se pueden dar como constantes de la clase Pattern: Pattern.CASE_INSENSITIVE es lo mismo que (?i), y Pattern.UNICODE_CHARACTER_CLASS que (?U). Usaremos la clase Pattern en la próxima lección.
• "a|b".split("|") es una trampa como la del punto: | es «o», y el patrón está vacío. Escribe split("\\|").

Pruébalo

Código postal

Un código postal búlgaro tiene exactamente cuatro dígitos. ¿Qué falta para que el programa imprima true para "1000" y false para "100" o "10000"?

String code = "1000";
System.out.println(code.matches(""));

Comprobar

Ejercicio

Comprobaciones con un patrón

Resuelve los ejercicios en tu editor. Lee líneas mientras haya: while (in.hasNextLine()). En la lección «Archivos» leerás las mismas líneas desde un archivo.

1. Fecha. Comprueba si cada fecha tiene la forma dd/mm/aaaa. El día va de 01 a 31, y el mes de 01 a 12. Pista: el día es 0[1-9] o [12]\d, o 3[01].

Entrada

01/01/2020
32/01/2020
15/05/2021

Salida

01/01/2020 - Válida
32/01/2020 - No válida
15/05/2021 - Válida

2. Número de móvil. La gente escribe los números con espacios y guiones. Quítalos con replaceAll y comprueba lo que queda con el patrón de número de móvil de la lección.

Entrada

0888 123 456
+359 87 765 4321
02 812 3456
0899-12-345

Salida

0888 123 456 - válido
+359 87 765 4321 - válido
02 812 3456 - no válido
0899-12-345 - no válido

3. Email. Comprueba si cada línea parece un email: una o más letras latinas, dígitos, ., + o -, después @, y después un nombre de dominio con al menos un punto (empresa.es, mail.empresa.es).

Entrada

lucia.garcia@empresa.es
lucia@empresa
@empresa.es
lucia garcia@empresa.es

Salida

lucia.garcia@empresa.es - sí
lucia@empresa - no
@empresa.es - no
lucia garcia@empresa.es - no

4. Lista de la compra. Los productos están separados por comas, puntos y comas, barras verticales o espacios, a veces varios a la vez. Imprímelos numerados.

Entrada

pan, leche;café  té|queso

Salida

1. pan
2. leche
3. café
4. té
5. queso

Más precisamente, para curiosos

• El patrón de la fecha también acepta 31/02/2026. Una regex no puede saber de forma razonable si el día existe en ese mes. Para eso está java.time.LocalDate, y el patrón es solo el primer filtro.

• La regla completa de una dirección de email (RFC 5322) permite comillas, comentarios y espacios en ciertos lugares. Un patrón que lo cubra todo tiene cientos de caracteres, y nadie lo mantiene. La comprobación de verdad es enviar un email con un enlace de confirmación.

Más ejercicios

• Contraseña. Comprueba si la contraseña tiene al menos 8 caracteres y al menos un dígito. Hazlo con dos matches: ".{8,}" y ".*\\d.*".
• Hora. Comprueba una hora con la forma hh:mm, de 00:00 a 23:59.
• Solo dígitos. De "Tel.: +359 (88) 812-34-56" deja solo los dígitos y el +, con un solo replaceAll y [^...].

Test

Ponte a prueba

1. ¿Qué comprueba "2026".matches("\\d{4}")?

Si el texto empieza con 4 dígitosSi todo el texto son exactamente 4 dígitosSi el texto tiene al menos 4 dígitos en alguna parte

2. ¿Con qué coincide . (un punto) en un patrón?

Solo con un puntoCon cualquier carácter (excepto el salto de línea)Con el final de una frase

3. ¿Cuál significa «uno o más»?

*+?

4. ¿Coincide "Zürich" con \w+ en Java?

Solo si está en minúsculasSí, \w es cualquier letraNo: \w son solo letras latinas sin acentos, dígitos y _

5. ¿Cuántas partes da "pan, leche;café".split("[,;]\\s*")?

213

Comprobar

Empezar la lección de nuevo

Lecciones relacionadas

• Se basa en: Métodos · Parámetros y return · Excepciones · Cadenas
• Continúa en: Expresiones regulares: grupos y reemplazo · Datos en archivos · Streams · Programación en red
• Ejercicios sobre el tema: Texto y archivos