Vericode
Entrar

Fundamentos de programación Tema 6

Expresiones regulares

Funciona en el IDE online. Todo lo de esta sección funciona en el IDE online: pulsa Pruébalo en cualquier ejemplo, o abre el IDE y escribe el tuyo. Sin instalar nada.

Con contains o startsWith se busca un texto concreto. Pero muchas veces lo que se quiere saber es si un texto tiene una forma: si un DNI son ocho cifras y una letra, si un código postal son cinco cifras, si en una frase hay números y cuáles son. Para eso están las expresiones regulares: un texto que describe una forma, con unos símbolos que significan «una cifra», «una letra», «una o más veces»…

Java
String dni = "12345678Z";
System.out.println(dni.matches("\\d{8}[A-Z]"));   // true

\\d{8}[A-Z] se lee: una cifra (\d), ocho veces ({8}), y después una letra mayúscula ([A-Z]). matches dice si el texto entero tiene esa forma.

Importante

En la expresión se escribe \d, pero dentro de un String de Java la barra \ es especial (es la de \n), así que hay que escribirla dos veces: "\\d". Es lo que más se olvida.

Los símbolos#

SímboloSignificaEjemploCumplen
\dUna cifra, del 0 al 9"\\d\\d""07", "42"
\wUna letra sin tilde, una cifra o _"\\w+""ana_2"
\sUn espacio, un tabulador o un salto de línea"a\\sb""a b"
.Cualquier carácter"c.sa""casa", "cosa"
[abc]Uno de los de dentro"[aeiou]""e"
[a-z], [0-9]Uno del rango"[A-Z][a-z]+""Ana"
[^…]Uno que no sea de los de dentro"[^0-9]+""hola"
a|bUna cosa o la otra"si|no""si", "no"
( )Junta un trozo, para repetirlo o para sacarlo luego"(ja)+""jajaja"

Y detrás de cualquiera de ellos, cuántas veces puede salir:

DetrásCuántas vecesEjemploCumplen
?Ninguna o una"colou?r""color", "colour"
*Ninguna o más"ab*""a", "abbb"
+Una o más"\\d+""5", "2026"
{n}Exactamente n"\\d{5}""28013"
{n,m}Entre n y m"\\d{2,4}""12", "2026"

Para buscar uno de los caracteres especiales tal cual (un punto, un +, un paréntesis), se pone \\ delante: "\\." es un punto de verdad, y no «cualquier carácter».

Comprobar un formato: matches#

matches dice si el texto entero, de principio a fin, cumple la expresión. Es lo que se usa para comprobar lo que escribe el usuario:

Java
String codigoPostal = "28013";
String telefono = "612 345 678";
String correo = "ana.lopez@correo.es";

System.out.println(codigoPostal.matches("\\d{5}"));                     // true
System.out.println(telefono.matches("[67]\\d{2} \\d{3} \\d{3}"));       // true
System.out.println(correo.matches("[\\w.]+@\\w+\\.[a-z]{2,}"));          // true
System.out.println("2801".matches("\\d{5}"));                            // false: faltan cifras

Nota

Comprobar un correo electrónico de verdad es mucho más complicado que esto: la expresión de arriba deja fuera direcciones válidas. Para un ejercicio vale; en un programa real se usa una que ya esté hecha y probada.

Cambiar y partir: replaceAll y split#

replaceAll cambia cada trozo que cumple la expresión por otro texto, y replaceFirst, solo el primero. split, que ya conoces, también recibe una expresión regular:

Java
String frase = "Hay   demasiados    espacios";
System.out.println(frase.replaceAll("\\s+", " "));     // Hay demasiados espacios

String tarjeta = "1234 5678 9012 3456";
System.out.println(tarjeta.replaceAll("\\d{4} ", "**** "));   // **** **** **** 3456

String lista = "pan,  leche ,huevos";
String[] cosas = lista.split("\\s*,\\s*");   // una coma, con o sin espacios alrededor
System.out.println(cosas.length + ": " + cosas[1]);   // 3: leche

Buscar dentro de un texto: Pattern y Matcher#

matches mira el texto entero. Para encontrar los trozos que cumplen la expresión dentro de un texto más largo, se usan dos clases de java.util.regex: Pattern, la expresión preparada, y Matcher, que la va buscando:

Java
import java.util.regex.*;

Pattern numero = Pattern.compile("\\d+");
Matcher m = numero.matcher("Tengo 3 gatos, 12 peces y 1 perro");
while (m.find()) {
    System.out.println(m.group() + " en la posición " + m.start());
}
Salida
3 en la posición 6
12 en la posición 15
1 en la posición 26
MétodoQué hace
find()Busca el siguiente trozo que cumple la expresión. Da false cuando ya no hay más
group()El trozo encontrado
group(n)El trozo de los paréntesis número n de la expresión, contados desde 1
start() y end()Dónde empieza el trozo, y la posición de después

Los paréntesis sirven para sacar partes de lo encontrado. Aquí, el usuario y el dominio de cada correo:

Java
import java.util.regex.*;

Pattern correo = Pattern.compile("(\\w+)@(\\w+)\\.com");
Matcher m = correo.matcher("Escribe a ana@gmail.com o a luis@empresa.com");
while (m.find()) {
    System.out.println("Usuario: " + m.group(1) + ", dominio: " + m.group(2));
}
Salida
Usuario: ana, dominio: gmail
Usuario: luis, dominio: empresa

Varios rangos seguidos: una matrícula#

Una matrícula española son cuatro cifras y tres consonantes:

Java
String matricula = "1234BCD";
System.out.println(matricula.matches("\\d{4}[B-DF-HJ-NP-TV-Z]{3}"));   // true
System.out.println("1234ABC".matches("\\d{4}[B-DF-HJ-NP-TV-Z]{3}"));    // false: lleva una vocal

[B-DF-HJ-NP-TV-Z] son varios rangos seguidos: de la B a la D, de la F a la H… para dejar fuera las vocales, que las matrículas no usan.

Errores frecuentes#

Mensaje o síntomaQué significaCómo se arregla
illegal escape characterHas escrito "\d" con una sola barra: para Java, \d no existe dentro de un textoDobla la barra: "\\d"
matches da false y el texto sí contiene lo que buscasmatches comprueba el texto entero, no un trozoPara buscar dentro, usa Pattern y find(); o rodea la expresión: ".*\\d.*"
PatternSyntaxException: Unclosed character classAl ejecutar: la expresión está mal escrita, aquí con un [ sin su ]Revisa que cada [, ( y { tenga su pareja
IllegalStateException: No match foundAl ejecutar: has pedido group() sin haber encontrado nadaPide el trozo solo si find() ha dado true: if (m.find()) { … m.group() … }
Un punto encuentra cualquier letraEn una expresión, . es «cualquier carácter»Para un punto de verdad, "\\."
cannot find symbol en Pattern o MatcherFalta el importAñade import java.util.regex.*; arriba del todo