Java / Expresiones regulares (1a. parte)

Bienvenidos sean a este post, hoy hablaremos sobre las expresiones regulares en Java.

Estas son una secuencia especial de caracteres que sirven para encontrar o coincidir otras cadenas o conjunto de cadenas usando una sintaxis especializada contenida en una patron, esta funcion esta provista por medio del paquete java.util.regex y finalmente estas pueden ser usadas para buscar, editar y manipular texto y datos, este paquete contiene principalmente estas tres clases:

• Pattern class, un objeto modelo es una representacion compilada de las expresiones regulares, esta clase no provee constructores publicos, para crearlo primero debes invocar una de las metodos publicos estaticos de compile(), el cual retornara un objeto modelo (pattern) y estos metodos aceptan una expresion regular como primer argumento.
• Matcher class, un objeto de esta clase es el motor encargado de interpretar el modelo (pattern) y ejecuta operaciones de coincidencia contra una cadena de entrada, como la clase anterior tampoco declara constructores publicos, este objeto se logra por medio del metodo matcher() sobre un objeto modelo (pattern)
• PatternSyntaxException, el objeto creado de esta clase es una excepcion sin chequear que devuelve un error de sintaxis en un modelo de expresion regular.

Pasemos a hablar sobre los grupos de captura, estas son una forma de tratar multiples caracteres como una unidad simple, para lograr esto se ponen los caracteres agrupados dentro de un conjunto de parentesis, los grupos se cuentan los parentesis de izquierda a derecha, por ejemplo:
((A)(B(C))), contiene cuatro grupos, puedes utilizar el metodo groupCount() en el objeto matcher, este metodo retorna un valor de tipo int mostrando la cantidad de grupos, veamos ahora la sintaxis de una expresion regular:

Subexpresion	Coincidencia
^	Coincide con el comienzo de la linea
$	Coincide con el final de la linea
.	Coincide con cualquier caracter excepto el de nueva linea
[…]	Coincide cualquier caracter dentro de los corchetes
[^…]	Coincide cualquier caracter fuera de los corchetes
\A	Comienzo de la cadena entera
\z	Final de la cadena entera
\Z	idem al \z excepto por el terminador de la linea permitido
re*	Coincide con 0 o más apariciones de la expresión anterior.
re+	Coincide con 1 o mas de lo anterior
re?	Coincide con 0 o 1 aparición de la expresión anterior.
re{ n}	Coincide exactamente n cantidad de veces de la expresion anterior
re{ n,}	Coincide n o mayor cantidad de veces de la expresion anterior
re{ n,m}	Coincide con al menos n y como máximo m ocurrencias de la expresión anterior.
a|b	Coincide con a o b
(re)	Agrupa expresiones regulares y almacena el texto coincidido
(?:re)	Igual al anterior pero sin recordar la coincidencia
(?>re)	Coincide con el patrón independiente sin retroceso.
\w	Coincide los caracteres de la palabra
\W	Coincide con los caracteres sin palabra
\s	Coincide con los espacios en blanco, equivalente a [\t\n\r\f]
\S	Coincide con los espacios no en blanco
\d	Coincide con los digitos, equivale a [0-9]
\D	Coincide con los no digitos
\A	Coincide con el comienzo de la cadena
\Z	Coincide con el final de la cadena pero justo antes de la nueva linea
\z	Coincide con el final de la cadena
\G	Coincide con el punto donde el ultimo encuentro termino
\n	Referencia para capturar el numero de grupo «n»
\b	Coincide con los límites de palabras cuando está fuera de los corchetes. Coincide con el retroceso (0x08) cuando está dentro de los corchetes.
\B	Coincide con los límites sin palabras.
\t,\n,\r,\f	Coincide con el tab, nueva linea, retorno, form feed
\Q	Escape (cita) todos los caracteres hasta \ E.
\E	Finaliza la busqueda comenzada con \ Q.

Esta es la tabla que muestra toda la sintaxis de metacaracteres de expresión regular disponible en Java, pasemos a un pequeño ejemplo para entender un poco mejor el concepto de expresiones regulares:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches 
{
         public static void main (String args[])
         {
         String line = "Esta orden fue puesta por QT3000! Ok?";
         String pattern = "(.*)(\\d+)(.*)";
         Pattern r = Pattern.compile(pattern);
         Matcher m = r.matcher(line);
         if (m.find())
         {
         System.out.println("Valor encontrado: " + m.group(0) );
         System.out.println("Valor encontrado: " + m.group(1) );
         System.out.println("Valor encontrado: " + m.group(2) );
         } else {
         System.out.println("No hubo coincidencias");
         }
         }
 }

En este caso importaremos dos paquetes, una de clase Matcher y otro de la clase Pattern, en el cuerpo de main() crearemos dos variables de tipo String, una llamada line donde estara almacenada la cadena a analizar, luego esta la variable pattern donde guardaremos los parametros de nuestra busqueda, despues creamos un objeto de la clase Pattern llamado r y pueden ver como lo compilamos con las expresiones de busqueda, nuestro siguiente objeto sera de la clase Matcher llamado m y ahi enviaremos el texto contenido en line, despues vendra un condicional if donde por medio del metodo find() veremos si hay coincidencias, en caso negativo mostrara un mensaje, en caso afirmativo nos devolvera tres lineas con los valores obtenidos de cada uno de nuestros grupos, si lo compilamos y ejecutamos obtendremos la siguiente salida:

tinchicus@dbn001vrt:~/java/program$ java RegexMatches
Valor encontrado: Esta orden fue puesta por QT3000! Ok?
Valor encontrado: Esta orden fue puesta por QT300
Valor encontrado: 0
tinchicus@dbn001vrt:~/java/program$

Como pueden ver el primer grupo devuelve todo el texto, group(0), el segundo grupo devuelve hasta el digito que coincide mas de una vez, y en el ultimo caso nos devuelve el ultimo digito coincidido por nosotros, tambien observen que en el segundo grupo usamos \\d+ en lugar de \d+ esto es debido a que la barra invertida (\) es un caracter de escape de estos lenguajes y necesitamos aclararle que es un modificador de expresion regular.

En resumen, hoy hemos visto de forma basica que son y para se usan las expresiones regulares, algunas de las clases utilizadas, como son sus modificadores para efectuar una busqueda de coincidencia y por ultimo un ejemplo para graficarlo, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.