Expresiones regulares en Java

Java proporciona el paquete java.util.regex para la coincidencia de

patrones con expresiones regulares. Las expresiones regulares de Java
son muy similares al lenguaje de programación Perl y muy fáciles de
aprender.

Una expresión regular es una secuencia especial de caracteres que le

ayuda a hacer coincidir o encontrar otras cadenas o conjuntos de
cadenas, utilizando una sintaxis especializada contenida en un patrón.
Se pueden utilizar para buscar, editar o manipular texto y datos.

El paquete java.util.regex consta principalmente de las siguientes

tres clases:

Pattern Class- Un objeto Pattern es una representación compilada de

una expresión regular. La clase Pattern no proporciona constructores
públicos. Para crear un patrón, primero debe invocar uno de sus
estáticos públicoscompile () métodos, que luego devolverán un objeto
Pattern. Estos métodos aceptan una expresión regular como primer
argumento.
Matcher Class- Un objeto Matcher es el motor que interpreta el patrón
y realiza operaciones de coincidencia con una cadena de entrada.
Como la clase Pattern, Matcher no define constructores públicos.
Obtienes un objeto Matcher invocando elmatcher () método en un
objeto Pattern.

PatternSyntaxException - Un objeto PatternSyntaxException es una

excepción sin marcar que indica un error de sintaxis en un patrón de
expresión regular.

Capturar grupos

La captura de grupos es una forma de tratar a varios personajes como

una sola unidad. Se crean colocando los caracteres a agrupar dentro
de un par de paréntesis. Por ejemplo, la expresión regular (perro) crea
un solo grupo que contiene las letras "d", "o" y "g".

Los grupos de captura se numeran contando sus paréntesis de apertura

de izquierda a derecha. En la expresión ((A) (B (C))), por ejemplo,
hay cuatro grupos de este tipo:

((A)(B(C)))

(A)

(B(C))

(C)
Para saber cuántos grupos están presentes en la expresión, llame al
método groupCount en un objeto de comparación. El método
groupCount devuelve unint mostrando el número de grupos de
captura presentes en el patrón del emparejador.

También hay un grupo especial, el grupo 0, que siempre representa la

expresión completa. Este grupo no está incluido en el total informado
por groupCount.

Ejemplo:

El siguiente ejemplo ilustra cómo encontrar una cadena de dígitos

de la cadena alfanumérica dada:

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class RegexMatches {

public static void main( String args[] ) {

// String to be scanned to find the pattern.

String line = "This order was placed for QT3000! OK?";

String pattern = "(.*)(\\d+)(.*)";

// Create a Pattern object

Pattern r = Pattern.compile(pattern);
 // Now create matcher object.

Matcher m = r.matcher(line);

if (m.find( )) {

System.out.println("Found value: " + m.group(0) );

System.out.println("Found value: " + m.group(1) );

System.out.println("Found value: " + m.group(2) );

}else {

System.out.println("NO MATCH");

Esto producirá el siguiente resultado:

Output

Found value: This order was placed for QT3000! OK?

Found value: This order was placed for QT300

Found value: 0