Java - Expresiones regulares
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 buscar o hacer coincidir otras cadenas o conjuntos de cadenas mediante una sintaxis especializada contenida en un patrón. Se pueden usar para buscar, editar o manipular texto y datos.
El paquete java.util.regex consta principalmente de las siguientes tres clases −
-
Clase de patrón − 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 compile() estáticos públicos métodos, que luego devolverán un objeto Patrón. Estos métodos aceptan una expresión regular como primer argumento.
-
Clase de coincidencia − Un objeto Matcher es el motor que interpreta el patrón y realiza operaciones de coincidencia con una cadena de entrada. Al igual que la clase Pattern, Matcher no define constructores públicos. Obtienes un objeto Matcher invocando el matcher() en un objeto Pattern.
-
Excepción de sintaxis de patrón − Un objeto PatternSyntaxException es una excepción no comprobada que indica un error de sintaxis en un patrón de expresión regular.
Captura de grupos
Los grupos de captura son una forma de tratar a varios personajes como una sola unidad. Se crean colocando los caracteres a agrupar dentro de un conjunto de paréntesis. Por ejemplo, la expresión regular (perro) crea un único 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 de esos grupos −
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
Para averiguar cuántos grupos están presentes en la expresión, llame al método groupCount en un objeto comparador. El método groupCount devuelve un int mostrando el número de grupos de captura presentes en el patrón del comparador.
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 a partir de la cadena alfanumérica dada −
Demostración en vivo
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 −
Salida
Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT300 Found value: 0
Sintaxis de expresiones regulares
Aquí está la tabla que enumera toda la sintaxis de metacaracteres de expresión regular disponible en Java −
| Subexpresión | Coincidencias |
|---|---|
| ^ | Coincide con el principio de la línea. |
| $ | Coincide con el final de la línea. |
| . | Coincide con cualquier carácter individual excepto nueva línea. Usando m La opción permite que coincida con la nueva línea también. |
| [...] | Coincide con cualquier carácter individual entre paréntesis. |
| [^...] | Coincide con cualquier carácter único que no esté entre paréntesis. |
| \A | Comienzo de toda la cadena. |
| \z | Fin de toda la cadena. |
| \Z | Final de toda la cadena excepto el terminador de línea final permitido. |
| re* | Coincide con 0 o más ocurrencias de la expresión anterior. |
| re+ | Coincide con 1 o más de lo anterior. |
| re? | Coincide con 0 o 1 aparición de la expresión anterior. |
| re{ n | Coincide exactamente con el número n de ocurrencias de la expresión anterior. |
| re{ n, | Coincide con n o más ocurrencias de la expresión anterior. |
| re{n, m | Coincide con al menos n y como máximo m ocurrencias de la expresión anterior. |
| a| b | Coincide con a o b. |
| (re) | Agrupa expresiones regulares y recuerda el texto coincidente. |
| (?:re) | Agrupa expresiones regulares sin recordar el texto coincidente. |
| (?> re) | Coincide con el patrón independiente sin retroceder. |
| \w | Coincide con los caracteres de la palabra. |
| \W | Coincide con los caracteres que no son palabras. |
| \s | Coincide con el espacio en blanco. Equivalente a [\t\n\r\f]. |
| \S | Coincide con el espacio no en blanco. |
| \d | Coincide con los dígitos. Equivalente a [0-9]. |
| \D | Coincide con los que no son dígitos. |
| \A | Coincide con el principio de la cadena. |
| \Z | Coincide con el final de la cadena. Si existe una nueva línea, coincide justo antes de la nueva línea. |
| \z | Coincide con el final de la cadena. |
| \G | Coincide con el punto donde terminó el último partido. |
| \n | Referencia inversa para capturar el número de grupo "n". |
| \b | Coincide con los límites de la palabra cuando está fuera de los corchetes. Coincide con el retroceso (0x08) cuando está dentro de los corchetes. |
| \B | Coincide con los límites de las no palabras. |
| \n, \t, etc. | Coincide con saltos de línea, retornos de carro, tabulaciones, etc. |
| \Q | Escape (comilla) todos los caracteres hasta \E. |
| \E | Termina la cita iniciada con \Q. |
Métodos de la clase Matcher
Aquí hay una lista de métodos de instancia útiles −
Métodos de índice
Los métodos de índice proporcionan valores de índice útiles que muestran con precisión dónde se encontró la coincidencia en la cadena de entrada −
| Sr.No. | Método y descripción |
|---|---|
| 1 | inicio int público() Devuelve el índice de inicio de la coincidencia anterior. |
| 2 | inicio int público (grupo int) Devuelve el índice de inicio de la subsecuencia capturada por el grupo dado durante la operación de coincidencia anterior. |
| 3 | fin público int() Devuelve el desplazamiento después del último carácter coincidente. |
| 4 | public int end (grupo int) Devuelve el desplazamiento después del último carácter de la subsecuencia capturada por el grupo dado durante la operación de coincidencia anterior. |
Métodos de estudio
Los métodos de estudio revisan la cadena de entrada y devuelven un valor booleano que indica si se encuentra o no el patrón −
| Sr.No. | Método y descripción |
|---|---|
| 1 | búsqueda booleana pública() Intenta hacer coincidir la secuencia de entrada, comenzando por el principio de la región, con el patrón. |
| 2 | búsqueda booleana pública() Intenta encontrar la siguiente subsecuencia de la secuencia de entrada que coincida con el patrón. |
| 3 | búsqueda booleana pública (inicio int) Restablece este comparador y luego intenta encontrar la siguiente subsecuencia de la secuencia de entrada que coincida con el patrón, comenzando en el índice especificado. |
| 4 | coincidencias booleanas públicas() Intenta hacer coincidir toda la región con el patrón. |
Métodos de sustitución
Los métodos de reemplazo son métodos útiles para reemplazar texto en una cadena de entrada −
| Sr.No. | Método y descripción |
|---|---|
| 1 | reemplazo de apéndice de Matcher público (StringBuffer sb, reemplazo de cadena) Implementa un paso de agregar y reemplazar sin terminal. |
| 2 | public StringBuffer appendTail(StringBuffer sb) Implementa un paso de agregar y reemplazar terminal. |
| 3 | cadena pública replaceAll (reemplazo de cadena) Reemplaza cada subsecuencia de la secuencia de entrada que coincida con el patrón con la cadena de reemplazo dada. |
| 4 | public String replaceFirst(Reemplazo de cadena) Reemplaza la primera subsecuencia de la secuencia de entrada que coincide con el patrón con la cadena de reemplazo dada. |
| 5 | Reemplazo de comillas de cadena estática pública (String s) Devuelve una cadena de reemplazo literal para la cadena especificada. Este método produce una cadena que funcionará como un reemplazo literal s en el método appendReplacement de la clase Matcher. |
Los métodos de inicio y final
El siguiente es el ejemplo que cuenta el número de veces que aparece la palabra "gato" en la cadena de entrada −
Ejemplo
Demostración en vivo
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = "\\bcat\\b";
private static final String INPUT = "cat cat cat cattie cat";
public static void main( String args[] ) {
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // get a matcher object
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
Esto producirá el siguiente resultado −
Salida
Match number 1 start(): 0 end(): 3 Match number 2 start(): 4 end(): 7 Match number 3 start(): 8 end(): 11 Match number 4 start(): 19 end(): 22
Puede ver que este ejemplo usa límites de palabras para garantizar que las letras "c" "a" "t" no sean simplemente una subcadena en una palabra más larga. También brinda información útil sobre dónde se produjo la coincidencia en la cadena de entrada.
El método de inicio devuelve el índice de inicio de la subsecuencia capturada por el grupo dado durante la operación de coincidencia anterior, y el final devuelve el índice del último carácter coincidente, más uno.
Los métodos Matches y LookingAt
Los métodos matches y lookingAt intentan hacer coincidir una secuencia de entrada con un patrón. La diferencia, sin embargo, es que las coincidencias requieren que coincida toda la secuencia de entrada, mientras que lookingAt no lo hace.
Ambos métodos siempre comienzan al principio de la cadena de entrada. Aquí está el ejemplo que explica la funcionalidad −
Ejemplo
Demostración en vivo
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static final String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
private static Pattern pattern;
private static Matcher matcher;
public static void main( String args[] ) {
pattern = Pattern.compile(REGEX);
matcher = pattern.matcher(INPUT);
System.out.println("Current REGEX is: "+REGEX);
System.out.println("Current INPUT is: "+INPUT);
System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}
Esto producirá el siguiente resultado −
Salida
Current REGEX is: foo Current INPUT is: fooooooooooooooooo lookingAt(): true matches(): false
Los métodos replaceFirst y replaceAll
Los métodos replaceFirst y replaceAll reemplazan el texto que coincide con una expresión regular determinada. Como indican sus nombres, replaceFirst reemplaza la primera ocurrencia y replaceAll reemplaza todas las ocurrencias.
Aquí está el ejemplo que explica la funcionalidad −
Ejemplo
Demostración en vivo
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = "dog";
private static String INPUT = "The dog says meow. " + "All dogs say meow.";
private static String REPLACE = "cat";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}
Esto producirá el siguiente resultado −
Salida
The cat says meow. All cats say meow.
Los métodos appendReplacement y appendTail
La clase Matcher también proporciona métodos appendReplacement y appendTail para el reemplazo de texto.
Aquí está el ejemplo que explica la funcionalidad −
Ejemplo
Demostración en vivo
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoob";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()) {
m.appendReplacement(sb, REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
Esto producirá el siguiente resultado −
Salida
-foo-foo-foo-
Métodos de clase PatternSyntaxException
Una PatternSyntaxException es una excepción no verificada que indica un error de sintaxis en un patrón de expresión regular. La clase PatternSyntaxException proporciona los siguientes métodos para ayudarlo a determinar qué salió mal:
| Sr.No. | Método y descripción |
|---|---|
| 1 | Cadena pública getDescription() Recupera la descripción del error. |
| 2 | getIndex público int() Recupera el índice de errores. |
| 3 | Cadena pública getPattern() Recupera el patrón de expresión regular erróneo. |
| 4 | Cadena pública getMessage() Devuelve una cadena de varias líneas que contiene la descripción del error de sintaxis y su índice, el patrón de expresión regular erróneo y una indicación visual del índice de error dentro del patrón. |
Java