Confundido sobre el grupo de Matcher en Java regex

Tengo la siguiente línea,

typeName="ABC:xxxxx;"; 

Necesito buscar la palabra ABC ,

Escribí el siguiente fragmento de código,

 Pattern pattern4=Pattern.compile("(.*):"); matcher=pattern4.matcher(typeName); String nameStr=""; if(matcher.find()) { nameStr=matcher.group(1); } 

Entonces, si pongo el group(0) obtengo ABC: pero si pongo el group(1) , es ABC , entonces quiero saber

  1. ¿Qué significa este 0 y 1 ? Será mejor si alguien puede explicarme con buenos ejemplos.

  2. El patrón regex contiene a : en él, entonces ¿por qué el resultado del group(1) lo omite? ¿El grupo 1 detecta todas las palabras dentro del paréntesis?

  3. Entonces, si pongo dos paréntesis más como, \\s*(\d*)(.*) : Entonces, ¿habrá dos grupos? group(1) devolverá la parte (\d*) y el group(2) devolverá la parte (.*) ?

El fragmento de código fue dado con el propósito de despejar mis confusiones. No es el código con el que estoy tratando. El código proporcionado anteriormente se puede hacer con String.split() de una manera mucho más sencilla.

Capturar y agrupar

El grupo de captura (pattern) crea un grupo que tiene propiedad de captura .

Una relacionada que a menudo puede ver (y usar) es (?:pattern) , que crea un grupo sin capturar propiedad, por lo tanto, se denomina grupo no capturable .

Un grupo se usa generalmente cuando necesita repetir una secuencia de patrones, por ejemplo, (\.\w+)+ , o para especificar dónde debe tener efecto la alternancia, por ejemplo ^(0*1|1*0)$ ( ^ , luego 0*1 o 1*0 , luego $ ) versus ^0*1|1*0$ ( ^0*1 o 1*0$ ).

Un grupo de captura, además de la agrupación, también registrará el texto que coincida con el patrón dentro del grupo de captura (pattern) . Usando su ejemplo, (.*): , .* Coincide con ABC y : coincide con : y dado que .* Está dentro del grupo de captura (.*) , El texto ABC se graba para el grupo de captura 1.

Número de grupo

El patrón completo se define como el número de grupo 0.

Cualquier grupo de captura en el patrón comienza a indexar desde 1. Los índices se definen por el orden de los paréntesis de apertura de los grupos de captura . Como ejemplo, aquí están los 5 grupos de captura en el siguiente patrón:

 (group)(?:non-capturing-group)(g(?:ro|u)p( (nested)inside)(another)group)(?=assertion) | | | | | | || | | 1-----1 | | 4------4 |5-------5 | | 3---------------3 | 2-----------------------------------------2 

Los números de grupo se utilizan en referencia atrás \n en el patrón y $n en cadena de reemplazo.

En otros sabores de expresiones regulares (PCRE, Perl), también se pueden usar en llamadas de sub-rutina .

Puede acceder al texto que coincide con cierto grupo con Matcher.group(int group) . Los números de grupo se pueden identificar con la regla indicada anteriormente.

En algunos sabores de expresiones regulares (PCRE, Perl), hay una función de reinicio de bifurcación que le permite usar el mismo número para capturar grupos en diferentes twigs de alternancia .

Nombre del grupo

Desde Java 7, puede definir un grupo de captura con nombre (?pattern) y puede acceder al contenido que coincide con Matcher.group(String name) . La expresión regular es más larga, pero el código es más significativo, ya que indica lo que está intentando hacer coincidir o extraer con la expresión regular.

Los nombres de grupo se usan en la referencia posterior \k en el patrón y ${name} en la cadena de reemplazo.

Los grupos de captura con nombre siguen numerados con el mismo esquema de numeración, por lo que también se puede acceder a ellos a través de Matcher.group(int group) .

Internamente, la implementación de Java simplemente asigna desde el nombre al número de grupo. Por lo tanto, no puede usar el mismo nombre para 2 grupos de captura diferentes.

Para el rest de nosotros

Aquí hay un ejemplo simple y claro de cómo funciona esto

Regex: ([a-zA-Z0-9]+)([\s]+)([a-zA-Z ]+)([\s]+)([0-9]+)

Cadena: "!* UserName10 John Smith 01123 *!"

 group(0): UserName10 John Smith 01123 group(1): UserName10 group(2): group(3): John Smith group(4): group(5): 01123 

Como puede ver, he creado CINCO grupos que están encerrados entre paréntesis.

¡Incluí el! * Y *! a cada lado para hacerlo más claro. Tenga en cuenta que ninguno de esos caracteres está en el RegEx y, por lo tanto, no se producirá en los resultados. Grupo (0) simplemente le da la cadena completa (todos mis criterios de búsqueda en una sola línea). El grupo 1 se detiene justo antes del primer espacio porque el carácter del espacio no se incluyó en los criterios de búsqueda. Los grupos 2 y 4 son simplemente el espacio en blanco, que en este caso es literalmente un carácter de espacio, pero también podría ser una pestaña o un salto de línea, etc. El grupo 3 incluye el espacio porque lo puse en los criterios de búsqueda … etc.

Espero que esto tenga sentido.

Los paréntesis () se utilizan para habilitar la agrupación de frases de expresiones regulares.

El group(1) contiene la cadena que está entre paréntesis (.*) Así que .* En este caso

Y el group(0) contiene una cadena completa combinada.

Si tuviera más grupos (leer (...) ) sería puesto en grupos con los siguientes índices (2, 3, etc.).