Expresiones Regulares en Java

Una representación compilada de una expresión regular.

Una expresión regular, especificada por una cadena, debe ser compilada primero en una instancia de esta clase. El patrón resultante puede ser usado para crear un objeto Matcher que puede comparar secuencias arbitrarias de caracteres contra la expresión regular. Toda la lógica para realizar comparaciones reside en el objeto matcher, asi que varios de estos objetos pueden compartir el mismo patrón.

Una secuencia típica de invocación es la siguiente:

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

Un método matches es definido en la clase Pattern para conveniencia cuando la expresión regular será usada sólo una vez. Este método compila la expresión y compara la secuencia de entrada en una sola instrucción. La instrucción es equivalente a:

boolean b = Pattern.matches("a*b", "aaaaab");

La clase String también posee un método matches igual que la clase Pattern, el cual permite comparar una cadena con un expresión:

"aaaaab".matches("a*b");

Estas dos últimas formas son equivalentes a las primeras tres instrucciones, excepto que si se repiten varias veces pierde eficiencia ya que no permite que el patrón compilado sea reutilizado.

Instancias de esta clase son inmutables y son seguras para utilizar en procesamiento multihilo. Instancias de la clase Matcher no son seguras para este uso.

Si queremos cambiar la expresión utilizada podemos usar el método usePattern() de la siguiente forma:

Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matches();

Pattern p2 = Pattern.compile("a*b*"); //compila una expresión
m.usePattern(p2); //se cambia el patrón
boolean b2 = m.matches();

Expresiones Regulares

Clases de Caracteres

[abc] a, b, o c (forma simple)

[^abc] Cualquier caracter excepto a, b, o c (negación)

[a-zA-Z] a hasta z o A hasta Z, inclusive (rango)

[a-d[m-p]] a hasta d, o m hasta p: [a-dm-p] (unión)

[a-z&&[def]] d, e, o f (intersección)

[a-z&&[^bc]] a hasta z, excepto para b y c: [ad-z] (sustracción)

[a-z&&[^m-p]] a hasta z, y no m hasta p: [a-lq-z](sustracción)

Clases de Caracteres Predefinidas

. Cualquier caracter

\d Un dígito: [0-9]

\D No dígito: [^0-9]

\s Un caracter blanco: [ \t\n\x0B\f\r]

\S No caracter blanco: [^\s]

\w Un caracter de palabra: [a-zA-Z_0-9]

\W No caracter de palabra: [^\w]

Cuantificadores

X? X, cero o una vez

X* X, cero o más veces

X+ X, una o más veces

X{n} X, exactamente n veces

X{n,} X, al menos n veces

X{n,m} X, al menos n veces pero no más de m veces

Operadores Logicos

XY X seguido por Y

X|Y X o Y

(X) X, como un grupo

Precedencia

1 Caracter de escape \x

2 Agrupación [...]

3 Rango a-z

4 Unión [a-e][i-u]

5 Intersección [a-z&&[aeiou]]

Metacaracteres:
([{\^-$|]})?*+

Si se desea comparar estos caracteres en las expresiones se debe utilizar alguna de las siguientes formas:

precederlo con un backslash, o
colocarlo entre \Q (que inicia la cita) y \E (que la termina).

Ejemplo:

[\^] ó [\Q^\E] sólo acepta el caracter ^

Clases de Caracteres POSIX (sólo US-ASCII)

\p{Lower} Una letra minúscula: [a-z]
\p{Upper} Una letra mayúscula:[A-Z]
\p{ASCII} Todos los caracteres ASCII:[\x00-\x7F]
\p{Alpha} Un caracter del alfabeto: [\p{Lower}\p{Upper}]
\p{Digit} Un dígito decimal: [0-9]
\p{Alnum} Un caracter alfanumérico: [\p{Alpha}\p{Digit}]
\p{Punct} Signo de Puntuación: Alguno entre !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} Un caracter visible: [\p{Alnum}\p{Punct}]
\p{Print} Un caracter imprimible: [\p{Graph}\x20]
\p{Blank} Un espacio en blanco o un tabular: [ \t]
\p{Cntrl} Un caracter de control: [\x00-\x1F\x7F]
\p{XDigit} Un dígito hexadecimal: [0-9a-fA-F]
\p{Space} Un caracter blanco: [ \t\n\x0B\f\r]

Ejemplos de Expresiones Regulares

1. Que sólo permita la palabra "hola"

[h][o][l][a]
hola

2. Que permita la palabra "hola" con cualquier combinacion de mayusculas y minusculas

[hH][oO][lL][aA]

3. Que permita una de las cadenas siguientes: col, lol, sol

[cls]ol

4. Que permita cualquier caracter al inicio, excepto “c” “l” “s”. Debe terminar con las letras “o” “l”. Permite gol, mol, etc, etc.

[^cls]ol

5. Que permita un dígito del 1 al 5

[12345]
[1-5]

6. Que permita un dígito que no esté entre el 1 y el 5

[67890]
[^1-5]

7. Que permita los dígitos del 0 al 4 y del 6 al 8 (0,1,2,3,4,6,7,8)

[01234678]
[0-4[6-8]]
[0-46-8]

8. Permita los dígitos del 0 al 4 que estén entre el 3 y el 5

[34]
[0-4&&[345]]
[0-4&&[3-5]]

9. Permite los dígitos del 0 al 9 que no estén entre el 4 y 6

[0123789]
[0-37-9]
[0-9&&[^456]]
[0-9&&[^4-6]]

10. Cero o una Z.Son válidas las cadenas “” y “Z”

Z?

11. Cero o más Z. Son válidas las cadenas “”, “Z”, “ZZ”, “ZZZ”, etc

Z*

12. Una o más Z. Son válidas las cadenas “Z”, “ZZ”, “ZZZ”, etc.

Z+

13. Permita una o más veces la palabra sol: solsolsol

(sol)+

14. Permita la cadena “so” seguida de l o más “l”

sol+

15. Permita las letras abc (en cualquier combinación de longitud 3): aab, bca, ccb, ...

[abc]{3}

16. Permita las letras abc (en cualquier combinación de longitud 3 o más): aabc, bca, ccb, ...

[abc]{3,}

17. Permita las letras abc (en cualquier combinación de longitud entre 3 y 6): aabc, bca, ccb, ...

[abc]{3,6}

18. Permita la palabra “hola” o “adios”

([h][o][l][a])|([a][d][i][o][s])

19. Lenguaje de 0 y 1 que tenga exactamente 2 ceros

[1]*[0][1]*[0][1]*

20 Lenguaje que soporte enteros con o sin signo

[\-+]?[0-9]+

21. Lenguaje de identificadores compuestos por letras y digitos. El identificador debe comenzar con una letra y terminar con letra o digito.

[a-zA-Z][a-zA-Z0-9]*