Cargando

Ir a contenido


 


Trabajando con expresiones regulares en Java

En este tutorial veremos cómo trabajar con expresiones regulares en el lenguaje de programación Java.


Escrito por el nov 21 2014 01:24 java


En los sistemas de información de la actualidad es normal ver funciones de búsqueda, dichas funciones cada vez necesitan procesar patrones de muchos más complejos. Para poder considerar cada caso en particular se necesitarían unos cuantos miles de años, es por ello que se han desarrollado mecanismos que permiten establecer una representación formulada de las búsquedas.

Dichas formulas las podemos encontrar en las expresiones regulares, que nos permiten establecer patrones para evaluación de cadenas de texto y retornar un valor positivo o negativo si dicha cadena corresponde o no a la formula expresada.

En Java podemos implementar las expresiones regulares de una forma sencilla, pero esto requiere de un estudio por parte del desarrollador un poco extenso para que pueda aprender los diferentes elementos con los que cuenta.

Sintaxis


La forma en la que podemos expresar las formulas con las cuales podemos probar nuestros patrones con una construcción particular de código, a esto lo vamos a llamar la sintaxis de las expresiones regulares.

¿Qué nos permite la sintaxis?
Lo que nos permite la sintaxis es establecer patrones por tipo de carácter, cantidad, combinación de carácter y cantidades, iniciar con un elemento en particular, establecer una expresión para el centro de la formula y un final. Con ello podemos lograr identificar patrones muy específicos que puedan ser necesitados en nuestro programa o tal vez filtrar de una manera más adecuada alguna búsqueda sobre un texto o una base de datos.


Veamos a continuación un pequeño listado de los elementos más utilizados en las expresiones regulares con Java, existen muchos más elementos que los mostrados en este tutorial por lo que se recomienda hacer una investigación a cuenta propia para reforzar conocimientos:

Inicio de Linea
\^ Con este elemento procedemos a indicar a Java que se inicia una línea en la expresión regular.


Fin de Linea
$ Con este símbolo indicamos que hemos finalizado la línea.


Lista de caracteres
[] Con corchetes indicamos a la expresión regular que debe buscar por cualquiera de los listados dentro.


Excluir
[\^] Nos permite seleccionar cualquier carácter que no esté listado.


Cuantificador
{j,k} Ubica lo que esté en j la cantidad de veces que indique k; {j, } en este segundo caso debe aparecer lo que esté en j una o más veces; por último {j} indica que debe aparecer lo que está en j una única vez.


Caracteres word
\w Ubica los caracteres que pertenezcan a word, pero si utilizamos \W hace lo contrario ubica los caracteres que no pertenecen.


Dígitos
\d Nos permite hacer coincidencias con solo dígitos y si utilizamos \D haremos coincidencias con todo lo que no sea un dígito o carácter numérico.


Espacios en blanco
\s Nos permite hacer coincidencias con espacios en blanco como tabs, barra espaciadora, pero si utilizamos \S hace lo contrario nos da coincidencia con todo lo que no sea espacio en blanco.


Como vemos con estos pocos elementos podremos construir varias combinaciones con las cuales podremos llegar a obtener patrones relativamente complejos.

Probar una expresión regular


Si queremos probar una expresión regular antes de compilar un programa podemos utilizar la página rubular.com donde podremos evaluar los patrones en tiempo real.


Vamos a realizar un ejemplo sencillo donde vamos a probar una expresión regular para validar un correo electrónico, utilizaremos la siguiente:

^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$

Primero debemos ingresar la expresión regular en el primer campo del formulario de la página de rubular.com luego en el campo llamado your test string es donde vamos a probar diferentes correos electrónicos para verificar que la expresión regular está funcionando, veamos cómo se comporta el validador cuando ingresamos un correo inválido:


Como podemos ver a nuestro correo electrónico de ejemplo le falta el punto, por lo que es inválido y no genera ningún match con la expresión regular, vamos a corregirlo colocando el punto faltante y automáticamente el validador genera una respuesta positiva permitiéndonos ver que nuestra expresión regular funciona sin ningún problema.


Como pudimos apreciar esto es un recurso muy útil cuando estamos aprendiendo a utilizar las expresiones regulares no solo en Java si no en cualquier lenguaje.

Búsqueda por patrón


Una vez que sabemos qué hace cada uno de los elementos básicos de la sintaxis, ahora debemos aprender cómo podemos hacer una búsqueda por un patrón dentro de Java, con ello podremos ver que métodos, clases y paquetes entran en juego cuando utilizamos expresiones regulares.

Lo primero que debemos saber es que todas estas utilidades se encuentran en el paquete java.util.regex, por lo que para hacer estos ejemplos debemos incluir dicho paquete al inicio de nuestras clases.

Una vez hecho lo anterior podemos probar por un patrón de la siguiente forma:

if (nuestraCadena.matches(nuestraExpresion)) {
//Si coincide aquí ejecutamos un código
}

Vemos que utilizamos el método matches(), este va a evaluar la cadena de caracteres contra el patrón de expresión regular y devolverá true o false, en caso que la cadena de caracteres coincida o no con el patrón.

Este tipo de uso está bien en pequeñas validaciones, sin embargo si vamos a utilizar una validación recurrente, es decir, que va a aparecer muchas veces dentro de nuestro programa, lo mejor es hacer una pequeña rutina o clase que nos permita evaluar el string de forma paramétrica, es decir, una rutina o método que nos permita ingresar un string y nos devuelva true o false, ya comparando contra un patrón en particular.

En el siguiente programa vamos a probar un pequeño patrón y lo vamos a evaluar contra un par de cadenas o strings y el programa nos dirá cual hace match, es decir, cual coincide y cual no, veamos el código y luego veremos su funcionamiento:

import java.util.regex.*;
public class PruebaPatrones {
public static void main(String[] argv) {
	 String patron = "^Q[^u]\\d+\\.";
	 String[] input = {
		 "QA777. es el identificador de nuestro producto.",
		 "Quack, Quack, Quack!"
	 };
	 Pattern p = Pattern.compile(patron);
	 for (String in : input) {
		 boolean encontrado = p.matcher(in).lookingAt();
		 System.out.println("'" + patron + "'" +
		 (encontrado ? " coincide '" : " no coincide '") + in + "'");
	 }
}
}

Aquí vemos como lo primero que hacemos es importar el paquete mencionado al inicio de esta sección, para poder obtener de esta manera las funcionalidades de la búsqueda por expresiones regulares. Luego construimos un patrón el cual utilizaremos es nuestro programa, en este caso es un patrón que hace coincidencia con la letra “Q” luego debe llevar cualquier carácter excepto la letra “u” y debe finalizar con un punto. Luego compilamos nuestro patrón utilizando el método compile y podremos utilizarlo para hacer las coincidencias. Por ultimo si el patrón coincide se imprime con la palabra coincide en caso contrario imprimimos no coincide.

Veamos en la siguiente imagen como luce esto cuando ejecutamos el programa:


Notamos entonces como según lo explicado el primer string o cadena si coincide, pero el segundo no y para mayor referencia colocamos el patrón sobre el cual debe hacerse la comparación.

Identificar que parte del string coincide


Vamos ahora a realizar un ejemplo más avanzado, vamos a identificar que parte de nuestro string coincide, esto es muy útil cuando estamos realizando búsquedas en texto, ya que con ello podríamos resaltar las coincidencias de lo que introduzca el usuario.

Para ello vamos a utilizar la misma base de nuestro programa anterior con algunas modificaciones, veamos el código y luego la explicación del mismo:

import java.util.regex.*;
public class QueCoincide {
public static void main(String[] argv) {
	 String patron = "Q[^u]\\d+\\.";
	 Pattern r = Pattern.compile(patron);
	 String texto = "El id es: QW990. fin de la prueba!";
	 Matcher m = r.matcher(texto);
	 if (m.find()) {
		 System.out.println(patron+ " coincide \"" +
			 m.group(0) +
			 "\" dentro de \"" + texto + "\"");
	 } else {
		 System.out.println("No hay coincidencias");
	 }
}
}

Una vez más vemos como iniciamos nuestro programa incluyendo el paquete java.util.regex.*. Luego utilizamos el mismo patrón del programa anterior y lo compilamos con el método compile, lo interesante viene ahora, hemos utilizado el método matcher() para ubicar la coincidencia y luego con el método find() y el método group() podemos extraer exactamente que coincide, finalmente hacemos las impresiones en pantalla correspondientes. Veamos como luce nuestro programa ahora:


Así vemos entonces como pudimos aislar la palabra que realmente coincide con el patrón que hemos dispuesto para la comparación de la expresión regular.

Aplicaciones de las expresiones regulares


Una de las aplicaciones más utilizadas es sobre los formularios, donde podemos hacer validaciones de correos electrónicos, números telefónicos, tarjetas de crédito, contraseñas, direcciones IP, nombres de usuarios, códigos postales e incluso validar que todas nuestras etiquetas en nuestro documento HTML estén correctamente cerradas, esto dándonos la posibilidad de conseguir mayor seguridad en nuestro procesamiento de texto ingresado por usuarios.

Pero no solo en validaciones en campos de un formulario, como notamos en nuestro último ejemplo también podemos hacer búsquedas en textos largos por un patrón en particular, con ello podemos buscar en documentos de texto muy complejos de forma sistemática y así ahorrar una gran cantidad de tiempo, simplemente escribiendo un pequeño programa.

Con esto finalizamos este tutorial, hemos aprendido como podemos ir desde tener diferentes elementos para expresar situaciones dentro de nuestros patrones hasta efectivamente hacer las comparaciones correspondientes del texto o caracteres que deseamos evaluar, todo esto gracias a las expresiones regulares. Estas evaluaciones son bastantes veloces gracias a las optimizaciones que hace el lenguaje en los métodos que nos ofrece, por lo que nos resultan muy oportunas para la construcción de interfaces donde necesitamos hacer búsquedas y validaciones de texto que el usuario introduce.
¿Te ha gustado y ayudado este Tutorial?
Puedes premiar al autor pulsando este botón para darle un punto positivo
  • -
  • 0
8
VOTA
5
0%
4
100%
3
0%
2
0%
1
0%

  Información

  •   Publicado nov 21 2014 01:24
  •   Actualizado nov 23 2014 23:12
  •   Visitas 2.5K
  •   Nivel
    Profesional



Tutoriales Relacionados


Sin comentarios, sé el primero!

No esperes más y entra en Solvetic
Deja tus comentarios y aprovecha las ventajas de la cuenta de usuario ¡Únete!
Demuestra que eres experto!
  ESCRIBIR TUTORIAL
Suscribirse