Expresiones regulares en Java

En este artículo vamos a explicar y ver el uso con ejemplos de expresiones regulares en Java. Las expresiones regulares las cuales son muy útiles a veces también pueden resultar algo complejas.

¿Qué es una expresión regular en Java?

Podemos definir una expresión regular como una secuencia de carácteres que forman una secuencia o patron que puede ser automatizada de alguna manera.

Por ejemplo, dentro de un texto queremos eliminar todas las palabras que sean «la» podemos usar un patrón para eliminarlas. Una expresión regular nos va a permitir buscar o reemplazar una secuencia.

¿Qué necesitamos en Java para crear una expresión regular?

Para poder hacer uso de expresiones regulares en Java necesitamos importar el paquete regex, el cual fue introducido en la versión 1.4 de Java.

La clase regex nos aporta las siguientes clases:

• Matcher: Esta clase nos permite hacer match sobre la secuencia de caracteres que nos define el Pattern.
• MatchResult: El resultado de la operación al hacer match
• Pattern: Es la representación de la expresión regular.
• PatternSyntaxException: Se lanza una Unchecked Exception para indicar un error de expresión en el patrón.

Cómo crear expresión regular en Java

Para crear una expresión regular haremos uso de los cuantificadores y metacaracteres.

Cuantificadores para una expresión regular

Tenemos caracteres especiales que nos van a indicar el número de repeticiones de la expresión, la siguiente tabla muestra los caracteres:

Cuantificador	Descripción
n+	Encuentra cualquier string con al menos un «n»
n*	Encuentra cero o más ocurrencias de n
n?	Encuentra en el string la aparición de n cero o una vez
n{x}	Encuentra la secuencia de n tantas veces como indica x.
n{x,}	Encuentra una secuencia de X tantas veces como indica n

Metacaracteres en una expresión regular

Metacaracter	Descripción
|	Símbolo para indicar OR.
.	Encuentra cualquier carácter
^	Sirve para hacer match al principio del string
$	Hace match al final de un String
\d	Encuentra dígitos
\s	Busca un espacio
\b	Hace match al principio de una palabra.
\uxxxx	Encuentra el carácter Unicode especificado por el número hexadecimal xxxx

Metacaracteres y ejemplos con expresiones regulares

Expresión regular	Descripción
.	Hace match con cualquier caracter
^regex	Encuentra cualquier expresión que coincida al principio de la línea.
regex$	Encuentra la expresión que haga match al final de la línea.
[abc]	Establece la definición de la expresión, por ejemplo la expresión escrita haría match con a, b o c.
[abc][vz]	Establece una definición en la que se hace match con a, b o c y a continuación va seguido por v o por z.
[^abc]	Cuando el símbolo ^ aparece al principio de una expresión después de [, negaría el patrón definido. Por ejemplo, el patrón anterior negaría el patrón, es decir, hace match para todo menos para la a, la b o la c.
[e-f]	Cuando hacemos uso de -, definimos rangos. Por ejemplo, en la expresión anterior buscamos hacer match de una letra entre la e y la f.
Y|X	Establece un OR, encuentra la Y o la X.
HO	Encuentra HO
$	Verifica si el final de una línea sigue.

Agrupar grupos en la expresión regular

Podemos agrupar una parte de nuestra expresión regular con paréntesis. Además de poder agrupar, podemos crear una referencia posterior de la expresión, es decir, una referencia que se hace más tarde almacena la parte de string que coincide con el grupo.

Para poder referirnos a un grupo en concreto haremos uso del símbolo del $, por ejemplo:

Eliminar las palabras «hola» y «adios»:

String pattern = "(\\hola)(\\qué)(adios)";
System.out.println(TEXT.replaceAll(pattern, "$1$3"));

Es decir, con el código anterior hemos cogido los patrones 1 y 3 y lo hemos aplicado a nuestro texto.

Tratamiento del backslash en las expresiones regulares

El uso de backslash es algo que hay que tener en cuenta a la hora de definir nuestra expresión regular. El backslash \ es un carácter de escape en los Strings de Java. Por ejemplo si queremos definir en nuestra expresión \w tendríamos que usar \\w en nuestra expresión.

Usar Or en un patrón

Para hacer uso de Or en un patrón, utilizamos | por ejemplo:

.*(coche|azul).*

En el caso anterior nos encontraría dentro de un texto las palabras «coche» o «azul».

Negación de un patrón

Si necesitamos la negación de un patrón podemos hacer uso de (?!pattern), por ejemplo si queremos encontrar la palabra plátano que no este seguida por la ‘s’:

plátano(?!s)

Acciones específicas en un patrón

Podemos añadir tres diferentes acciones o modos para nuestra expresión regular:

• (?i) nuestra expresión será sensible a mayúsculas y minúsculas.
• (?m) o Pattern.MULTILINE para modo de múltiple línea, hace que la intercalación y el dolar coincida al principio y al final.
• (?s) o Pattern.DOTALL para modo de una única línea hace que el punto coincida al final de la línea.

Si queremos aplicar todos los modos sería de la siguiente manera: (?ismx).

Uso de Pattern y Matcher para crear expresiones regulares

Ya hemos visto como podemos crear o qué necesitamos para crear expresiones regulares, ahora vamos a ver como podemos crear las expresiones regulares haciendo uso de Pattern y Matcher.

Lo primero que vamos a hacer es hacer uso de Pattern en donde definimos la expresión regular, y a partir de aquí haremos uso de Matcher con el Pattern creado pasando por parámetro un String.

Por ejemplo:

Pattern pattern = Pattern.compile("\\w+");
Matcher matcher = pattern.matcher("Say Hi");

Ejemplos de Expresiones regulares en Java

A continuación vamos a ver diferentes ejemplos de expresiones en Java:

Encontrar todas las palabras de una cadena de texto:

A continuación vamos a ver como sería el patrón dado

  @Test
  void given_text_find_any_word() {

    String text = "Say Hi";
    Pattern pattern = Pattern.compile("\\w+");
    Matcher matcher = pattern.matcher(text);

    assertTrue(matcher.find());


  }

Encontrar todas las palabras que acaben en id seguido de null

  @Test
  void given_text_find_any_word_that_end_with_id_and_null() {

    String text = "carId:null";
    Pattern pattern = Pattern.compile("\\w*Id:null");
    Matcher matcher = pattern.matcher(text);

    assertTrue(matcher.find());


  }

En el ejemplo anterior definimos una expresión para encontrar todas las palabras terminadas en Id:null

Encontrar fechas con expresión regular

@Test
void given_text_find_dates() {

  String text = "2014-02-02";
  Pattern pattern = Pattern.compile("\\d{4}-\\d{2}-\\d{2}");
  Matcher matcher = pattern.matcher(text);

  assertTrue(matcher.find());

}

El ejemplo anterior buscaría cualquier fecha en un texto con el formato específicado (yyyy-mm-dd).

Encontrar la secuencia de caracteres que cumpla con un formato UUID.

@Test
void given_text_find_UUID() {
  String text = "aa8fe95b-db40-480b-b47c-949d5340d9df";
  Pattern pattern = Pattern.compile( "[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}");
  Matcher matcher = pattern.matcher(text);
  
  assertTrue(matcher.find());


}

El uso de UUID para crear Id’s en Base de Datos es bastante utilizado, la expresión anterior encuentra cualquier UUID en un texto.

Encontrar la secuencia de caracteres que cumpla con un correo electrónico:

@Test
void given_text_find_email() {
  String text = "refactorizando.web@gmail.com";
  Pattern pattern = Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
  Matcher matcher = pattern.matcher(text);
  
  assertTrue(matcher.find());

}

El ejemplo anterior define un patrón y formato de valores posibles para un correo electrónico, validando cualquier email que aparezca en un texto.

A destacar se hace uso de \\ para escapar el símbolo .

Encontrar palabras duplicadas

@Test
void given_text_find_duplicated_words() {
  String text = "Hola que que";
  Pattern pattern = Pattern.compile("\b(\w+)\s+\1\b", Pattern.CASE_INSENSITIVE);
  Matcher matcher = pattern.matcher(text);
  
  assertTrue(matcher.find());

}

Con \b se límita la palabra y con \1 se hace referencia de la coincidencia del primer grupo.

Conclusión

El uso expresiones regulares en Java nos va a facilitar crear y definir tareas para aquellos casos en los que necesitemos trabajar con String, por ejemplo reemplazar un UUID o cambiar el formato de una fecha.