Clases y Expresiones Regulares
Las expresiones regulares son
algo que se usa desde hace años en otros lenguajes de programación como Perl,
Sed o Awk. En la versión 1.4 del JDK de Sun se incluye el paquete
java.util.regex, que proporciona una serie de clases para poder hacer uso de la
potencia de este tipo de expresiones en Java
Las expresiones regulares se
rigen por una serie de normas y hay una construcción para cualquier patrón de
caracteres.
ü para
comprobar que la fecha leída cumple el patrón dd/mm/aaaa
ü para
comprobar que un NIF está formado por 8 cifras, un guión y una letra
ü para
comprobar que una dirección de correo electrónico es una dirección válida.
ü para
comprobar que una contraseña cumple unas determinadas condiciones.
ü Para
comprobar que una URL es válida.
ü Para
comprobar cuántas veces se repite dentro de la cadena una secuencia de
caracteres determinada.
Uso
El paquete java.util.regex esta
formado por dos clases, la clase Matcher y la clase Pattern y por una
excepción, PatternSyntaxException.
- La
clase Pattern (segun la documentacion del jdk1.4)
es la representacion compilada de una expresion regular, o lo que es lo mismo,
representa a la expresion regular, que en el paquete java.util.regex necesita
estar compilada. En castellano significa patrón.
- La
clase Matcher es un tipo de objeto que se crea a
partir de un patrón mediante la invocación del método Pattern.matcher. Este
objeto es el que nos permite realizar operaciones sobre la secuencia de
caracteres que queremos validar o la en la secuencia de caracteres en la que
queremos buscar.
Símbolos comunes en expresiones regulares
|
|
Descripción
|
|
.
|
Un
punto indica cualquier carácter
|
|
^expresión
|
El
símbolo ^ indica el principio del String. En este caso el String debe
contener la expresión al principio.
|
|
expresión$
|
El
símbolo $ indica el final del String. En este caso el String debe contener la
expresión al final.
|
|
[abc]
|
Los
corchetes representan una definición de conjunto. En este ejemplo el
String debe contener las letras a ó b ó c.
|
|
[abc][12]
|
El
String debe contener las letras a ó b ó c seguidas de 1 ó 2
|
|
[^abc]
|
El
símbolo ^ dentro de los corchetes indica negación. En este caso el String
debe contener cualquier carácter excepto a ó b ó c.
|
|
[a-z1-9]
|
Rango. Indica
las letras minúsculas desde la a hasta la z (ambas incluidas) y los dígitos
desde el 1 hasta el 9 (ambos incluidos)
|
|
A|B
|
El
carácter | es un OR. A ó B
|
|
AB
|
Concatenación.
A seguida de B
|
Meta caracteres
|
Expresión
|
Descripción
|
|
\d
|
Dígito.
Equivale a [0-9]
|
|
\D
|
No dígito.
Equivale a [^0-9]
|
|
\s
|
Espacio en blanco. Equivale a [
\t\n\x0b\r\f]
|
|
\S
|
No espacio en blanco. Equivale a [^\s]
|
|
\w
|
Una letra mayúscula o minúscula, un
dígito o el carácter _
Equivale a [a-zA-Z0-9_]
|
|
\W
|
Equivale a
[^\w]
|
|
\b
|
Límite de una
palabra.
|
Cuantificadores
|
Expresión
|
Descripción
|
|
{X}
|
Indica que lo que va justo antes de
las llaves se repite X veces
|
|
{X,Y}
|
Indica que lo que va justo antes de
las llaves se repite mínimo X veces y máximo Y veces. También podemos poner
{X,} indicando que se repite un mínimo de X veces sin límite máximo.
|
|
*
|
Indica 0 ó más veces. Equivale a {0,}
|
|
+
|
Indica 1 ó más veces. Equivale a {1,}
|
|
?
|
Indica 0 ó 1 veces. Equivale a {0,1}
|
Ejemplos de Expresiones Regulares en Java:
1. Comprobar si el
String cadena contiene exactamente el patrón (matches) “abc”
Pattern pat = Pattern.compile("abc");
Matcher
mat = pat.matcher(cadena);
if
(mat.matches()) {
System.out.println("SI");
}
else {
System.out.println("NO");
}
2. Comprobar si el
String cadena contiene “abc”
Pattern pat = Pattern.compile(".*abc.*");
Matcher
mat = pat.matcher(cadena);
if
(mat.matches()) {
System.out.println("SI");
}
else {
System.out.println("NO");
}
3. Comprobar si el
String cadena empieza por “abc”
Pattern pat =
Pattern.compile("^abc.*");
Matcher
mat = pat.matcher(cadena);
if
(mat.matches()) {
System.out.println("Válido");
}
else {
System.out.println("No
Válido");
}
4. Comprobar si el
String cadena empieza por “abc” ó “Abc”
Pattern pat =
Pattern.compile("^[aA]bc.*");
Matcher
mat = pat.matcher(cadena);
if
(mat.matches()) {
System.out.println("SI");
}
else {
System.out.println("NO");
}
5. Comprobar si el
String cadena está formado por un mínimo de 5 letras mayúsculas o
minúsculas y un máximo de 10.
Pattern pat =
Pattern.compile("[a-zA-Z]{5,10}");
Matcher
mat = pat.matcher(cadena);
if
(mat.matches()) {
System.out.println("SI");
}
else {
System.out.println("NO");
}
Webgrafía:
Programacion.net
http://programacion.net/articulo/expresiones_regulares_en_java_127
