Expresiones regulares de Java

Las expresiones regulares definen patrones de cadenas.

Las expresiones regulares se pueden utilizar para buscar, editar o manipular texto.

Las expresiones regulares no se limitan a un idioma, sino que existen diferencias sutiles en cada idioma.

Las expresiones regulares de Java son más similares a las de Perl.

El paquete java.util.regex incluye principalmente las siguientes tres clases:

• Clase de patrón:

  El objeto de patrón es una representación compilada de una expresión regular. La clase de patrón no tiene constructor público. Para crear un objeto Pattern, primero debe llamar a su método de compilación estática pública, que devuelve un objeto Pattern. Este método acepta una expresión regular como primer parámetro.

• Clase de emparejamiento:

  El objeto Matcher es un motor que interpreta y compara cadenas de entrada. Al igual que la clase Pattern, Matcher no tiene un constructor público. Debe llamar al método matcher del objeto Pattern para obtener un objeto Matcher.

• Excepción de sintaxis de patrón:

  PatternSyntaxException es una clase de excepción no obligatoria que representa un error de sintaxis en un patrón de expresión regular.

grupo de captura

La captura de grupos es una forma de tratar varios personajes como una sola unidad, creada agrupando personajes entre paréntesis.

Por ejemplo, la expresión regular (perro) crea un único grupo que contiene "d", "o" y "g".

Los grupos de captura se numeran contando sus corchetes iniciales de izquierda a derecha. Por ejemplo, en la expresión ((A)(B(C))), hay cuatro grupos de este tipo:

• ((ABECEDARIO)))

• (A)

• (ANTES DE CRISTO))

• (DO)

Puede comprobar cuántos grupos tiene una expresión llamando al método groupCount del objeto coincidente. El método groupCount devuelve un valor int, lo que indica que el objeto coincidente tiene actualmente varios grupos de captura.

También hay un grupo especial (grupo 0) que siempre representa la expresión completa. El grupo no está incluido en el valor de retorno de groupCount.

Ejemplo

El siguiente ejemplo muestra cómo encontrar una cadena de dígitos a partir de una cadena determinada:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

clase pública RegexMatches
{
principal vacío estático público (argumentos de cadena []) {

// Busca la cadena según el patrón especificado String line = "¡Este pedido fue realizado para QT3000! ¿OK?";
Patrón de cadena = "(.*)(\d+)(.*)";

//Crear objeto Patrón Patrón r = Pattern.compile(pattern);

// Ahora crea un objeto comparador Matcher m = r.matcher(line);
si (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) );
} demás {
System.out.println("NO HAY COINCIDENCIA");
}
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 Valor encontrado: Este pedido se realizó por QT3000, ¿vale?
Valor encontrado: Este pedido fue realizado por QT300
Valor encontrado: 0

Sintaxis de expresión regular

Métodos de la clase Matcher

método de índice

El método de índice proporciona valores de índice útiles que indican exactamente en qué parte de la cadena de entrada se encuentra la coincidencia:

métodos de investigación

El método de investigación examina la cadena de entrada y devuelve un valor booleano que indica si se encontró el patrón:

método de reemplazo

El método de reemplazo es un método para reemplazar texto en la cadena de entrada:

métodos de inicio y fin

A continuación se muestra un ejemplo de cómo contar el número de apariciones de la palabra "gato" en una cadena de entrada:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

clase pública RegexMatches
{
cadena final estática privada REGEX = "\bcat\b";
Cadena final estática privada ENTRADA =
"gato gato gato gato gato";

principal vacío estático público (argumentos de cadena []) {
Patrón p = Patrón.compile(REGEX);
Matcher m = p.matcher(INPUT); // Obtener el objeto de comparación int count = 0;

while(m.buscar()) {
contar++;
System.out.println("Número de coincidencia "+cuenta);
System.out.println("inicio(): "+m.inicio());
System.out.println("end(): "+m.end());
}
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 Partido número 1
inicio(): 0
final(): 3
Partido número 2
inicio(): 4
final(): 7
Partido número 3
inicio(): 8
final(): 11
Partido número 4
inicio(): 19
final(): 22

Puede ver que este ejemplo utiliza límites de palabras para garantizar que las letras "c" "a" "t" no sean solo una subcadena de una palabra más larga. También proporciona información útil sobre en qué parte de la cadena de entrada se produjo la coincidencia.

El método de inicio devuelve el índice inicial de la subsecuencia capturada por el grupo dado durante la operación de coincidencia anterior, y el método de finalización agrega uno al índice del último carácter coincidente.

coincidencias y métodos de búsqueda

Los métodosmatches ylookingAt se utilizan para intentar hacer coincidir un patrón de secuencia de entrada. La diferencia entre ellos es que las coincidencias requieren que toda la secuencia coincida, mientras que LookingAt no.

Estos dos métodos se utilizan a menudo al principio de la cadena de entrada.

Usamos el siguiente ejemplo para explicar esta función:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

clase pública RegexMatches
{
cadena final estática privada REGEX = "foo";
Cadena final estática privada ENTRADA = "fooooooooooooooooo";
patrón de patrón estático privado;
comparador estático privado;

principal vacío estático público (argumentos de cadena []) {
patrón = Patrón.compile(REGEX);
comparador = patrón.matcher(ENTRADA);

System.out.println("REGEX actual es: "+REGEX);
System.out.println("La ENTRADA actual es: "+ENTRADA);

System.out.println("mirando(): "+matcher.mirando());
System.out.println("coincidencias(): "+matcher.matches());
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 REGEX actual es: foo
La ENTRADA actual es: fooooooooooooooooo
mirando(): verdadero
coincidencias(): falso

métodos reemplazarPrimero y reemplazarTodos

Los métodos replaceFirst y replaceAll se utilizan para reemplazar texto que coincide con una expresión regular. La diferencia es que reemplazarPrimero reemplaza la primera coincidencia y reemplazarTodo reemplaza todas las coincidencias.

El siguiente ejemplo explica esta funcionalidad:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

clase pública RegexMatches
{
Cadena estática privada REGEX = "perro";
cadena estática privada ENTRADA = "El perro dice miau." +
"Todos los perros dicen maullar.";
Cadena estática privada REPLACE = "gato";

público estático vacío principal (String [] argumentos) {
Patrón p = Patrón.compile(REGEX);
//obtenemos un objeto coincidente
Emparejador m = p.matcher(ENTRADA);
ENTRADA = m.reemplazarTodo(REEMPLAZAR);
System.out.println(ENTRADA);
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 El gato dice miau. Todos los gatos dicen miau.

Métodos appendReplacement y appendTail

La clase Matcher también proporciona métodos appendReplacement y appendTail para reemplazar texto:

Mire el siguiente ejemplo para explicar esta funcionalidad:

 importar java.util.regex.Matcher;
importar java.util.regex.Pattern;

clase pública RegexMatches
{
Cadena estática privada REGEX = "a*b";
Cadena estática privada INPUT = "aabfooaabfooabfoob";
Cadena estática privada REPLACE = "-";
público estático vacío principal (String [] argumentos) {
Patrón p = Patrón.compile(REGEX);
// Obtener el objeto comparador Matcher m = p.matcher(INPUT);
StringBuffer sb = nuevo StringBuffer();
mientras(m.buscar()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

Los resultados de compilación y ejecución del ejemplo anterior son los siguientes:

 -foo-foo-foo-

Métodos de la clase PatternSyntaxException

PatternSyntaxException es una clase de excepción no forzada que indica un error de sintaxis en un patrón de expresión regular.

La clase PatternSyntaxException proporciona los siguientes métodos para ayudarnos a ver qué errores ocurrieron.