Expresiones Regulares en Java – Ejemplo de Expresiones Regulares en Java

Bienvenido a Expresiones Regulares en Java. También se le llama Regex en Java. Cuando empecé a programar, las expresiones regulares en java eran una pesadilla para mí. Este tutorial tiene como objetivo ayudarte a dominar las Expresiones Regulares en Java. También volveré aquí para refrescar mi aprendizaje de Java Regex.

Expresiones Regulares en Java

La expresión regular en java define un patrón para una cadena. Las Expresiones Regulares se pueden utilizar para buscar, editar o manipular texto. Una expresión regular no es específica del lenguaje, pero difieren ligeramente para cada lenguaje. Las Expresiones Regulares en Java son más similares a Perl. Las clases de Regex de Java están presentes en el paquete java.util.regex que contiene tres clases:

1. Patrón: El objeto Patrón es la versión compilada de la expresión regular. La clase Patrón no tiene ningún constructor público y usamos su método estático público compile para crear el objeto patrón pasando el argumento de la expresión regular.
2. Matcher: Matcher es el objeto del motor de expresiones regulares de Java que coincide el patrón de cadena de entrada con el objeto de patrón creado. La clase Matcher no tiene ningún constructor público y obtenemos un objeto Matcher usando el método matcher del objeto de patrón que toma la cadena de entrada como argumento. Luego usamos el método matches que devuelve un resultado booleano basado en si la cadena de entrada coincide o no con el patrón regex.
3. PatternSyntaxException: PatternSyntaxException se lanza si la sintaxis de la expresión regular no es correcta.

Echemos un vistazo al ejemplo de programa de Regex de Java.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// mala expresión regular
		pattern = Pattern.compile("*xx*");

	}

}

Cuando ejecutamos este ejemplo de programa de regex de Java, obtenemos la siguiente salida.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Dado que la expresión regular de Java gira en torno a String, la clase String se ha extendido en Java 1.4 para proporcionar un método matches que realiza coincidencias de patrones regex. Internamente, utiliza las clases regex de Java Pattern y Matcher para realizar el procesamiento, pero obviamente reduce las líneas de código. La clase Pattern también contiene el método matches que toma regex y cadena de entrada como argumento y devuelve un resultado booleano después de hacer coincidir. Por lo tanto, el siguiente código funciona bien para hacer coincidir la cadena de entrada con una expresión regular en Java.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Así que si su requisito es simplemente verificar si la cadena de entrada coincide con el patrón, debería ahorrar tiempo y líneas de código utilizando el método de coincidencia de cadenas simple. Debería utilizar las clases Pattern y Matches solo cuando necesite manipular la cadena de entrada o necesite reutilizar el patrón. Tenga en cuenta que el patrón definido por regex se aplica en la cadena de izquierda a derecha y una vez que un carácter fuente se utiliza en una coincidencia, no se puede reutilizar. Por ejemplo, la regex “121” coincidirá con “31212142121” solo dos veces como “_121____121”.

Expresión Regular en Java – símbolos de coincidencia comunes

Metacaracteres de Java Regex

Tenemos algunos metacaracteres en regex de Java, son como códigos cortos para patrones de coincidencia comunes.

Hay dos formas de usar metacaracteres como caracteres ordinarios en expresiones regulares.

1. Anteceda el metacaracter con una barra invertida (\).
2. Mantenga el metacaracter dentro de \Q (que inicia la cita) y \E (que la termina).

Expresión Regular en Java – Cuantificadores

Los cuantificadores de Regex en Java especifican el número de ocurrencias de un carácter para hacer coincidir.

Los cuantificadores de Regex en Java también pueden utilizarse con clases de caracteres y grupos de captura. Por ejemplo, [abc]+ significa – a, b o c – una o más veces. (abc)+ significa el grupo “abc” una o más veces. Ahora discutiremos sobre Grupos de Captura.

Expresión Regular en Java – Grupos de Captura

Los grupos de captura en Expresiones Regulares de Java se utilizan para tratar múltiples caracteres como una unidad única. Puedes crear un grupo usando (). La porción de la cadena de entrada que coincide con el grupo de captura se guarda en la memoria y se puede recuperar usando Referencia Posterior. Puedes usar el método matcher.groupCount para averiguar el número de grupos de captura en un patrón de regex de Java. Por ejemplo, ((a)(bc)) contiene 3 grupos de captura – ((a)(bc)), (a) y (bc). Puedes usar Referencia Posterior en la expresión regular con una barra invertida (\) y luego el número del grupo que se va a recuperar. Los grupos de captura y las Referencias Posteriores pueden resultar confusos, así que vamos a entender esto con un ejemplo.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

En el primer ejemplo, en tiempo de ejecución, el primer grupo de captura es (\w\d), que se evalúa como “a2” cuando coincide con la cadena de entrada “a2a2” y se guarda en la memoria. Así que \1 se refiere a “a2” y, por lo tanto, devuelve verdadero. Por la misma razón, la segunda afirmación imprime falso. Trata de entender este escenario por ti mismo para las declaraciones 3 y 4. 🙂 Ahora veremos algunos métodos importantes de las clases Pattern y Matcher.

1. Podemos crear un objeto Pattern con indicadores. Por ejemplo, Pattern.CASE_INSENSITIVE permite la coincidencia sin distinción entre mayúsculas y minúsculas.
2. La clase Pattern también proporciona el método split(String), que es similar al método split() de la clase String.
3. El método toString() de la clase Pattern devuelve la cadena de expresión regular a partir de la cual se compiló este patrón.
4. Las clases Matcher tienen métodos de índice start() y end() que muestran exactamente dónde se encontró la coincidencia en la cadena de entrada.
5. La clase Matcher también proporciona métodos de manipulación de cadenas replaceAll(String replacement) y replaceFirst(String replacement).

Veamos estos métodos de regex en Java en un ejemplo de programa sencillo.

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// usando patrón con indicadores
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// usando los métodos find(), group(), start() y end() de Matcher
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// usando el método split() de Pattern
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// usando los métodos replaceFirst() y replaceAll() de Matcher
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

El resultado del programa de ejemplo de regex en Java anterior es.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

Eso es todo para Expresiones regulares en Java. Las Regex de Java parecen difíciles al principio, pero si trabajas con ellas durante algún tiempo, es fácil de aprender y usar.

Puedes consultar el código completo y más ejemplos de expresiones regulares en nuestro Repositorio de GitHub.