JDK8 Online Api Chinese Manual
JDK8 Online Api English Manual
Procesamiento de expresiones regulares
El paquete java.util.regex admite el procesamiento de expresiones regulares. Como el término se usa aquí, una expresión regular es una cadena de caracteres que describe una secuencia de caracteres. Este tipo de descripción se denomina patrón y se puede utilizar para buscar coincidencias en otras secuencias de caracteres. Las expresiones regulares pueden especificar comodines, un conjunto de caracteres y varios cuantificadores. Por lo tanto, puede especificar una forma común de expresión regular para que coincida con una variedad de diferentes series de caracteres específicos.
El procesamiento de expresiones regulares es compatible con dos clases: Pattern y Matcher. Las dos clases trabajan juntas: use la clase Patrón para definir expresiones regulares, y use la clase Matcher para unir patrones en otras secuencias.
1 clase de patrón
La clase Pattern no define un constructor. En cambio, el patrón se crea a través del método de fábrica compile (). Una forma de este método es la siguiente:
static Pattern compile(String pattern)
Entre ellos, el patrón es la expresión regular que desea usar. El método compile () convierte la cadena de caracteres del patrón en un patrón, que Matcher puede usar para la coincidencia de patrones. Este método devuelve un objeto Patrón que contiene el patrón.
Una vez que cree un objeto Patrón, puede usar el objeto Patrón para crear un objeto Matcher. Esto se hace a través de la fábrica matcher () definida por la clase Pattern. El método es el siguiente:
Matcher matcher(CharSequence str)
Entre ellos, str es una secuencia de caracteres que se utilizará para coincidir con el patrón, también conocida como secuencia de entrada. CharSequence es una interfaz que define un conjunto de caracteres de solo lectura. String y otras clases implementan esta interfaz, por lo que puede pasar una cadena al método matcher ().
2 clase de Matcher
La clase Matcher no tiene constructor. En cambio, como se acaba de explicar, el objeto Matcher se crea llamando al método de fábrica matcher () definido por Pattern. Una vez que se crea el objeto Matcher, puede usar los métodos del objeto Matcher para realizar varias operaciones de coincidencia de patrones.
El método de coincidencia de patrones más simple es coincidencias (). Este método simplemente determina si la secuencia de caracteres coincide con el patrón, de la siguiente manera:
boolean matches()
Si la secuencia de caracteres coincide con el patrón, devuelve verdadero; de lo contrario, devuelve falso. Lo que debe entenderse es que toda la secuencia debe coincidir con el patrón, no solo la subsecuencia coincide con el patrón.
Para determinar si la subsecuencia de la secuencia de entrada coincide con el patrón, debe usar el método find (). Una versión de este método es la siguiente:
boolean find()
Si hay una subsecuencia coincidente, devuelve verdadero; de lo contrario, devuelve falso. Este método se puede llamar repetidamente para encontrar todas las subsecuencias coincidentes. Cada llamada al método find () comienza desde la posición donde la dejó por última vez.
La cadena que contiene la última secuencia coincidente se puede obtener llamando al método group (). Una forma de este método es la siguiente:
String group()
Este método devuelve la cadena coincidente. Si no hay coincidencia, se lanza una IllegalException.
El índice de coincidencia actual en la secuencia de entrada se puede obtener llamando al método start (). A través del método end (), puede obtener el índice del siguiente carácter después del final de la secuencia de coincidencia actual. Los dos métodos son los siguientes:
int start();
int end();
Si no hay una secuencia coincidente, ambos métodos arrojarán una IllegalStateException.
Puede reemplazar todas las secuencias coincidentes con otra secuencia llamando al método replaceAll (), como se muestra a continuación:
String replaceAll(String newStr)
Entre ellos, newStr especifica una nueva secuencia de caracteres, que se utilizará para reemplazar la secuencia que coincide con el patrón. La secuencia de entrada actualizada se devuelve como una cadena.
3 Sintaxis de expresiones regulares
En general, las expresiones regulares se componen de caracteres regulares, clases de caracteres (un grupo de caracteres), comodines y cuantificadores. Los personajes regulares se corresponden según ellos mismos. Por lo tanto, si el patrón se construye a partir de "xy", entonces la única secuencia de entrada que coincide con el patrón es "xy". Los caracteres como los saltos de línea y las pestañas se especifican utilizando secuencias de escape estándar, que comienzan con "". Por ejemplo, el carácter de nueva línea se especifica con "\ n". En las expresiones regulares, los caracteres regulares también se denominan valores literales.
La clase de personaje es un grupo de personajes. Al colocar caracteres entre corchetes, puede especificar la clase de caracteres. Por ejemplo, la clase [wxyz] coincide con w, x, y, o z. Para especificar un conjunto de caracteres exclusivos, puede usar "^" delante de los caracteres. Por ejemplo, la clase [^ wxyz] coincide con caracteres distintos de w, x, y y z. Puede usar guiones para especificar rangos de caracteres. Por ejemplo, para especificar una clase de caracteres que coincida con los números del 1 al 9, puede usar [1-9].
El comodín es un punto (.) Y puede coincidir con cualquier carácter. Por lo tanto, un patrón compuesto de "." Coincidirá con las siguientes (y otras) secuencias de entrada: "A", "a", "x", etc.
El cuantificador determina cuántas veces se coincidirá la expresión. El cuantificador es el siguiente:
- +: Coincidir una o más veces
- .: Match cero o más veces
- ? : Coincide con cero o una vez.
Por ejemplo, el patrón "x +" coincidirá con "x", "xx" y "xxx".
Otro punto: en general, si la expresión especificada no es válida, se generará una PatternSyntaxException.
4 patrones de coincidencia de demostración
Para comprender el principio de la operación de coincidencia de patrones de expresión regular, la mejor manera es dar algunos ejemplos. El primer ejemplo se muestra a continuación, utilizando patrones literales para encontrar coincidencias:
import java.util.regex.Matcher;
import java.util.regex.Pattern;
//A simple pattern matching demo.
class RegExpr {
public static void main(String[] args) {
Pattern pat;
Matcher mat;
boolean found;
pat = Pattern.compile("Java");
mat = pat.matcher("Java");
found = mat.matches();//check for a match
System.out.println("Testing Java against Java.");
if (found) {
System.out.println("Matches");
} else {
System.out.println("No Match");
}
System.out.println();
System.out.println("Testing Java against Java 8.");
mat = pat.matcher("Java 8");
found = mat.matches();//check for a match
if (found) {
System.out.println("Matches");
} else {
System.out.println("No Match");
}
/**
* 输出：
* Testing Java against Java.
* Matches
*
* Testing Java against Java 8.
* No Match
*/
}
}
El programa se analiza en detalle a continuación. El programa primero crea un patrón que contiene la secuencia "Java". A continuación, cree un objeto Matcher para el patrón, que tiene la secuencia de entrada "Java". Luego, se llama al método coincide () para determinar si la secuencia de entrada coincide con el patrón. Debido a que la secuencia de entrada y el patrón son iguales, el método coincide () devuelve verdadero. Luego, use la secuencia de entrada "Java 8" para crear un nuevo objeto Matcher y vuelva a llamar al método match (). En este caso, el patrón y la secuencia de entrada son diferentes y no se encuentra ninguna coincidencia. Recuerde que el método coincide () devuelve verdadero solo cuando la secuencia de entrada coincide exactamente con el patrón; no devuelve verdadero si solo coincide la subsecuencia.
Puede usar el método find () para determinar si la secuencia de entrada contiene subsecuencias que coinciden con el patrón. Analice el siguiente programa:
//Use find() to find a subsequence.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr2 {
public static void main(String[] args) {
Pattern pat = Pattern.compile("Java");
Matcher mat = pat.matcher("Java 8");
System.out.println("Looking for Java in Java 8.");
if(mat.find()){
System.out.println("subsequence found");
}else{
System.out.println("No Match");
}
}
/**
* 输出：
* Looking for Java in Java 8.
* subsequence found
*/
}
En este ejemplo, el método find () encuentra la subsecuencia "Java".
Puede usar el método find () para encontrar el número de ocurrencias repetidas del patrón en la secuencia de entrada, porque cada llamada find () comienza desde el lugar donde la dejó por última vez. Por ejemplo, el siguiente programa puede encontrar dos coincidencias con el patrón "prueba".
//Use find() to find multiple subsequence.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr3 {
public static void main(String[] args) {
Pattern pat = Pattern.compile("test");
Matcher mat = pat.matcher("test 1 2 3 test");
while ((mat.find())){
System.out.println("test found at index "+mat.start());
}
}
/**
* 输出：
* test found at index 0
* test found at index 11
*/
}
Como muestra la salida, se encontraron dos coincidencias. El programa usa el método start () para obtener cada índice coincidente.
1. Use comodines y cuantificadores
Aunque los programas anteriores muestran la técnica general de usar las clases Pattern y Matcher, estos programas no muestran sus poderosas funciones. Solo cuando utiliza comodines y cuantificadores puede descubrir realmente los beneficios del procesamiento de expresiones regulares. Este ejemplo usa el cuantificador "+" para que coincida con cualquier secuencia de longitud "W".
//Use a quantifier.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr4 {
public static void main(String[] args) {
Pattern pat = Pattern.compile("W+");
Matcher mat = pat.matcher("W WW WWW");
while (mat.find()){
System.out.println("Match: "+mat.group());
}
}
/*
输出：
Match: W
Match: WW
Match: WWW
*/
}
Como muestra la salida, el patrón de expresión regular "W +" puede coincidir con secuencias W de cualquier longitud.
El siguiente programa usa comodines para crear un patrón que coincida con cualquier secuencia que comience con e y termine con d. Para lograr esto, use comodines de puntos y "+"; cuantificadores:
//Use wildcard and quantifier.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr5 {
public static void main(String[] args) {
Pattern pat = Pattern.compile("e.+d");
Matcher mat = pat.matcher("extend cup end table");
while ((mat.find())){
System.out.println("Match: "+mat.group());
}
}
/*
Match: extend cup end
*/
}
Solo se encuentra una coincidencia, y la secuencia más larga comienza con e y termina con d. Podemos esperar dos coincidencias: "extender" y "finalizar". La razón para encontrar secuencias más largas es que, por defecto, el método find () coincidirá con la secuencia más larga que se ajuste al patrón, que se llama "comportamiento codicioso". Puede especificar "comportamiento coercitivo" agregando cuantificadores "?" Al patrón, como se muestra en la siguiente versión, lo que dará como resultado el patrón de coincidencia más corto:
//Use the ? quantifier.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr6 {
public static void main(String[] args) {
//Use reluctant matching behavior.
Pattern pat = Pattern.compile("e.+?d");
Matcher mat = pat.matcher("extend cup end table");
while ((mat.find())) {
System.out.println("Match: " + mat.group());
}
}
/*
Match: extend
Match: end
*/
}
Como muestra la salida, el patrón "e. +? D" coincidirá con la secuencia más corta que comienza con e y termina con d. Por lo tanto, se encontraron dos coincidencias.
2. Usando clases de caracteres, a
veces desea incluir cualquier secuencia de uno o más caracteres en cualquier orden. Por ejemplo, para hacer coincidir una palabra completa, desea hacer coincidir cualquier secuencia del alfabeto. La forma más fácil de lograr esto es usar clases de caracteres. La clase de caracteres define un conjunto de caracteres. Las clases de caracteres se crean colocando los caracteres que desea unir entre corchetes. Por ejemplo, para hacer coincidir letras minúsculas de la a a la z, puede usar [az]. El siguiente programa demuestra esta técnica:
//Use a character class.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr7 {
public static void main(String[] args) {
//Match lowercase words.
Pattern pat = Pattern.compile("[a-z]+");
Matcher mat = pat.matcher("this is a test.");
while ((mat.find())){
System.out.println("Match: "+mat.group());
}
}
/*
输出：
Match: this
Match: is
Match: a
Match: test
*/
}
3. Utilice el método replaceAll ()
El método replaceAll () proporcionado por la clase Matcher se utiliza para realizar operaciones potentes de búsqueda y reemplazo utilizando expresiones regulares. Por ejemplo, el siguiente programa usa "Eric" para reemplazar todas las secuencias que comienzan con "Jon":
//Use replaceAll()
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class RegExpr8 {
public static void main(String[] args) {
String str="John Jonathan Frank Ken Todd";
Pattern pat = Pattern.compile("Jon.*? ");
Matcher mat =pat.matcher(str);
System.out.println("Original sequence: "+str);
str= mat.replaceAll("Eric ");
System.out.println("Modified sequence: "+str);
}
/*
输出：
Original sequence: John Jonathan Frank Ken Todd
Modified sequence: John Eric Frank Ken Todd
*/
}
Debido a que la expresión regular "Jon. *?" Coincide con cualquier cadena que comienza con Jon, seguida de cero o más caracteres y termina con un espacio, se puede usar para unir a Jon y Jonathan, y reemplazarlos con Eric. Si no se utiliza la función de coincidencia de patrones, este reemplazo es difícil de lograr.
4. Use el método split () para
usar el método split () definido por la clase Pattern para simplificar la serialización de entrada en un solo token. Una forma del método split () es la siguiente:
String[] split(CharSequence str)
Este método procesa la secuencia de entrada pasada por str y simplifica la secuencia de entrada en tokens de acuerdo con el delimitador especificado por el patrón:
//Use split().
import java.util.regex.Pattern;
class RegExpr9 {
public static void main(String[] args) {
//Match lowercase words.
Pattern pat = Pattern.compile("[ ,.!]");
String strs[] = pat.split("one two,alpha9 12!done.");
for (int i=0;i<strs.length;i++){
System.out.println("Next token: "+strs[i]);
}
}
/*
输出：
Next token: one
Next token: two
Next token: alpha9
Next token: 12
Next token: done
*/
}
Como muestra la salida, esta secuencia de entrada se reduce a una sola edición. Tenga en cuenta que el delimitador no está incluido.
5 Dos opciones para la coincidencia de patrones
Aunque las técnicas de coincidencia de patrones descritas anteriormente proporcionan la flexibilidad y la funcionalidad más poderosas, existen otras dos técnicas que pueden ser útiles en ciertos entornos. Si solo necesita realizar una coincidencia de patrones una vez, puede usar el método de coincidencias () definido por la clase Patrón. El método es el siguiente:
static boolean matches(String pattern,CharSequence str)
Si el patrón coincide con str, devuelve verdadero; de lo contrario, devuelve falso. Este método compila automáticamente el patrón y luego busca una coincidencia. Si necesita usar el mismo patrón repetidamente, usar los métodos definidos por la clase Matcher para que coincida con el patrón anterior y luego usar los métodos definidos por la clase Matcher es menos eficiente.
También puede usar el método de coincidencias () de la clase String para realizar la coincidencia de patrones, como se muestra a continuación:
boolean matches(String pattern)
Si la cadena de llamada coincide con la expresión regular en el patrón, el método coincide () devuelve verdadero, de lo contrario devuelve falso.
