Explicación detallada de las clases de patrones y casadores en expresiones regulares de Java

Prefacio

Este artículo presentará la clase de patrones y la clase Matcher en expresiones regulares de Java. En primer lugar, debemos comprender claramente que la expresión regular especificada como una cadena debe compilarse primero como una instancia de la clase de patrón. Por lo tanto, cómo comprender mejor estas dos clases es algo que los programadores deben saber.

Echemos un vistazo a estas dos categorías:

1. El concepto de capturar el grupo

El grupo de captura se puede numerar calculando sus soportes abiertos de izquierda a derecha, que comienza con 1. Por ejemplo, en la expresión ((a) (b (c))), hay cuatro de estos grupos:

 1 ((a) (b (c))) 2 (a) 3 (b (c)) 4 (c)

Los ceros del grupo siempre representan toda la expresión. Los grupos que comienzan con (?) Los grupos puros no capturantes que no capturan texto y no cuentan contra los recuentos combinados.

La entrada de captura asociada con un grupo es siempre la subsecuencia que coincide con el grupo más recientemente. Si el grupo se calcula nuevamente debido a la cuantización, su valor previamente capturado se conservará en la segunda falla de cálculo (si corresponde). Por ejemplo, coincidir la cadena "ABA" con la expresión (A (B)?)+ Establecerá el segundo grupo en "B". Al comienzo de cada partido, se descartan todas las entradas capturadas.

2. Explicación detallada de las clases de patrones y matcher

Las expresiones regulares de Java se implementan a través de la clase de patrones y la clase Matcher bajo el paquete java.util.regex (se recomienda que abra el documento de la API Java al leer este artículo. Al introducir qué método se introduce, verifique la descripción del método en la API Java y el efecto será mejor).

La clase de patrón se usa para crear una expresión regular, o se puede decir que crea un patrón de coincidencia. Su constructor es privado y no se puede crear directamente, pero puede crear una expresión regular a través del método simple de fábrica de Pattern.complie(String regex)

Ejemplo de código Java:

 Patrón p = patrón.compile ("// w+"); p.pattern (); // return/w+

pattern() Devuelve la forma de cadena de una expresión regular, que en realidad es el parámetro regex de Pattern.complile(String regex)

1.Pattern.Split (entrada de CharSequence)

El patrón tiene un método split(CharSequence input) , que se utiliza para separar las cadenas y devolver una cadena []. Supongo que String.split(String regex) se implementa a través de Pattern.split(CharSequence input) .

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Cadena [] str = P.Split ("Mi QQ es: 456456 Mi teléfono es: 0532214 Mi correo electrónico es: [email protected]");

Resultado: str [0] = "Mi qq es:" str [1] = "Mi teléfono es:" str [2] = "Mi correo electrónico es: [email protected]"

2. Pattern.Matcher (String Regex, CharSequence Input) es un método estático utilizado para hacer coincidir rápidamente las cadenas. Este método es adecuado para coincidir solo una vez y coincidir con todas las cadenas.

Ejemplo de código Java:

 Patrones.matches ("// d+", "2223"); // return true Pattern.matches ("// d+", "2223aa"); // return false, todas las cadenas deben coincidir para que se devuelvan true, aquí aa no se puede coincidir con patrones.matches ("// d+", "22bb23"); // return fals

3.Pattern.Matcher (entrada de CharSequence)

Después de decir tanto, finalmente es el turno de la clase Matcher para debutar. Pattern.matcher(CharSequence input) Devuelve un objeto Matcher.
El método de constructor de la clase Matcher también es privado y no se puede crear a voluntad. Solo puede obtener instancias de esta clase a través Pattern.matcher(CharSequence input) .
La clase de patrones solo puede hacer algunas operaciones de coincidencia simples. Para obtener operaciones de correspondencia regulares más fuertes y más convenientes, es necesario cooperar con patrón y combate. La clase Matcher proporciona soporte de agrupación para expresiones regulares y soporte de correspondencia múltiple para expresiones regulares.

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher m = p.matcher ("22bb23"); m.pattern (); // return P que debe devolver qué objeto de patrón fue creado por el objeto Matcher.

4.Matcher.Matches ()/matcher.lookingat ()/matcher.find ()

La clase Matcher proporciona tres métodos de operación coincidentes. Los tres métodos devuelven el tipo booleano. Regrese verdadero cuando se alcanza el partido. Si no hay coincidencia, devuelve falso.

matches() coincide con toda la cadena y devuelve verdadero solo si la cadena completa coincide

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher m = p.matcher ("22bb23"); M.Matches (); // return False, porque BB no puede coincidir con/D+, lo que resulta en la coincidencia de toda la cadena sin éxito. Matcher m2 = p.matcher ("2223"); m2.matches (); // return true, porque/d+ coincide con toda la cadena

Veamos hacia atrás en Pattern.matcher(String regex,CharSequence input) , que es equivalente al siguiente código
Pattern.compile(regex).matcher(input).matches()

lookingAt() coincide con la cadena anterior y devuelve verdadero solo si la cadena coincidente está en el frente.

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher m = p.matcher ("22bb23"); M.OOKINGAT (); // return True, porque/d+ coincide con los 22 mates anteriores m2 = p.matcher ("aa2223"); m2.lookingat (); // devuelve falso, porque/d+ no puede igualar el AA anterior

find() coincide con la cadena, y la cadena coincidente puede estar en cualquier lugar.

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher m = p.matcher ("22bb23"); M.Find (); // return True Matcher m2 = p.matcher ("AA2223"); m2.find (); // return True Matcher m3 = p.matcher ("aa2223bb"); m3.find (); // return True Matcher m4 = p.matcher ("aabb"); m4.find (); // return false

5.MathCer.start ()/matcher.end ()/matcher.group ()

Después de usar matches() , lookingAt() y find() para realizar operaciones coincidentes, puede usar los tres métodos anteriores para obtener información más detallada.

start() Devuelve la posición de índice de la subcadena coincidente en la cadena.

end() Devuelve la posición de índice del último carácter de la subcadena coincidente en la cadena.

group() Devuelve la subcadena coincidente

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher M = p.matcher ("AAA2223BB"); M.Find (); // Match 2223 M.start (); // return 3 m.end (); // return 7, el número de índice después de 2223 m.group (); // return 2223 mathcer m2 = m.matcher ("2223bb"); M.OOKINGAT (); // coincidir 2223 M.Start (); // return 0, ya que lookat () solo puede coincidir con la cadena anterior, cuando se usa lookat () para que coincida, el método Start () siempre devuelve 0 M.end (); // return 4 m.group (); // return 2223 matcher m3 = m.matcher ("2223bb"); m.matches (); // coincidir con toda la cadena m.start (); // regreso 0, creo que todos saben la razón m.end (); // Devuelve 6, creo que todos saben la razón, porque los partidos () necesitan coincidir con todas las cadenas m.group (); // devolver 2223bb

Habiendo dicho tanto, creo que todos entienden el uso de los métodos anteriores. Deberíamos hablar sobre cómo se usa la agrupación de expresión regular en Java.
Hay un método sobrecargado para start() , end() y group() Son start(int i) , end(int i) , group(int i) específicamente para operaciones grupales. La clase de Mathcer también tiene un groupCount() para devolver cuántos grupos hay.

Ejemplo de código Java:

 Patrón p = patrón.compile ("([AZ]+) (// d+)"); Matcher M = p.matcher ("AAA2223BB"); M.Find (); // coincidir con aaa2223 m.groupCount (); // regresa 2, porque hay 2 grupos de M.Start (1); // return 0 Devuelve el número de índice del primer grupo de sustras coincidentes en la cadena M.Start (2); // Devuelve 3 M.end (1); // Devuelve 3 Devuelve la posición de índice del último carácter del primer grupo de sustras coincidentes en la cadena. M.end (2); // Devuelve 7 M.Group (1); // Devuelve AAA, devuelve el primer grupo de sustras coincidentes M.Group (2); // return 2223, devuelve el segundo conjunto de sustros coincidentes

Ahora usemos una operación de coincidencia regular de nivel ligeramente superior, por ejemplo, hay un texto con muchos números, y estos números están separados. Ahora necesitamos sacar todos los números del texto. Es muy simple usar operaciones regulares de Java.

Ejemplo de código Java:

 Patrón p = patrón.compile ("// d+"); Matcher M = p.matcher ("Mi QQ es: 456456 Mi teléfono es: 0532214 Mi correo electrónico es: [email protected]"); while (m.find ()) {system.out.println (m.group ()); }

Producción:

 456456 0532214 123

Si reemplaza el bucle anterior while() con

 while (m.find ()) {system.out.println (m.group ()); System.out.print ("Start:"+M.Start ()); System.out.println ("End:"+m.end ()); }

Luego salida:

 456456 Inicio: 6 Fin: 12 0532214 Inicio: 19 Fin: 26 123 Inicio: 36 Fin: 39

Ahora todos deberían saber que después de cada operación coincidente, los valores de los tres métodos start() , end() y group() se cambiarán, y se cambiarán a la información de la subcadena coincidente, y sus métodos de sobrecarga también se cambiarán a la información correspondiente.

NOTA: Solo cuando la operación de coincidencia sea exitosa, ¿puede usar los tres métodos start() , end() y group() , de lo contrario java.lang.IllegalStateException se lanzará, es decir, cuando cualquiera de los métodos matches() , lookingAt() , find() return True, solo se puede usar.

Resumir

Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo sea de ayuda para su estudio o trabajo. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.