Confuso riguardo al gruppo Matcher nella regex di Java

Ho la seguente riga,

typeName="ABC:xxxxx;"; 

Ho bisogno di prendere la parola ABC ,

Ho scritto il seguente frammento di codice,

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

Quindi se metto group(0) ottengo ABC: ma se metto group(1) è ABC , quindi voglio sapere

  1. Cosa significa questo 0 e 1 ? Sarà meglio se qualcuno mi può spiegare con buoni esempi.

  2. Il modello regex contiene a : in esso, quindi perché il risultato del group(1) omette? Il gruppo 1 rileva tutte le parole all’interno della parentesi?

  3. Quindi, se inserisco altre due parentesi, come \\s*(\d*)(.*) : Allora, ci saranno due gruppi? group(1) restituirà la parte (\d*) e il group(2) restituiscono la parte (.*) ?

Il frammento di codice è stato dato in uno scopo per cancellare le mie confusioni. Non è il codice con cui mi sto occupando. Il codice sopra riportato può essere fatto con String.split() in un modo molto più semplice.

Cattura e raggruppamento

Catturare un gruppo (pattern) crea un gruppo che ha acquisito la proprietà.

Uno correlato che potresti vedere (e usare) è (?:pattern) , che crea un gruppo senza acquisire la proprietà, quindi denominato gruppo non catturante .

Un gruppo viene solitamente usato quando è necessario ripetere una sequenza di pattern, ad esempio (\.\w+)+ , o per specificare dove deve avvenire l’alternanza, ad esempio ^(0*1|1*0)$ ( ^ , quindi 0*1 o 1*0 , quindi $ ) rispetto a ^0*1|1*0$ ( ^0*1 o 1*0$ ).

Un gruppo che cattura, oltre al raggruppamento, registrerà anche il testo corrispondente al pattern all’interno del gruppo di cattura (pattern) . Usando il tuo esempio, (.*): , .* Corrisponde a ABC e : corrispondenze:, e poiché .* È all’interno del gruppo di cattura (.*) , Il testo ABC viene registrato per il gruppo di acquisizione 1.

Numero del gruppo

L’intero modello è definito come il numero di gruppo 0.

Qualsiasi gruppo di cattura nel modello inizia l’indicizzazione da 1. Gli indici sono definiti dall’ordine delle parentesi di apertura dei gruppi di cattura . Ad esempio, qui ci sono tutti e 5 i gruppi di cattura nello schema seguente:

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

I numeri di gruppo sono usati nel riferimento di ritorno \n nel modello e $n nella stringa di sostituzione.

In altri sapori regex (PCRE, Perl), possono essere utilizzati anche in chiamate sub-routine .

Puoi accedere al testo abbinato da un determinato gruppo con Matcher.group(int group) . I numeri di gruppo possono essere identificati con la regola sopra indicata.

In alcuni sapori regex (PCRE, Perl), esiste una funzione di reset del ramo che consente di utilizzare lo stesso numero per catturare i gruppi in diversi rami di alternanza .

Nome del gruppo

Da Java 7, è ansible definire un gruppo di acquisizione denominato (?pattern) ed è ansible accedere al contenuto corrispondente a Matcher.group(String name) . La regex è più lunga, ma il codice è più significativo, poiché indica ciò che stai cercando di abbinare o estrarre con l’espressione regolare.

I nomi dei gruppi sono usati nel riferimento al passato \k nel modello e ${name} nella stringa di sostituzione.

I gruppi di acquisizione con nome sono ancora numerati con lo stesso schema di numerazione, quindi è ansible accedervi anche tramite Matcher.group(int group) .

Internamente, l’implementazione di Java esegue solo il mapping dal nome al numero del gruppo. Pertanto, non è ansible utilizzare lo stesso nome per 2 diversi gruppi di acquisizione.

Per il resto di noi

Ecco un esempio semplice e chiaro di come funziona

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

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

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

Come puoi vedere, ho creato cinque gruppi che sono racchiusi tra parentesi.

Ho incluso il! * E *! da entrambi i lati per renderlo più chiaro. Si noti che nessuno di questi caratteri è presente nella RegEx e pertanto non verrà prodotto nei risultati. Il gruppo (0) fornisce semplicemente l’intera stringa con corrispondenza (tutti i miei criteri di ricerca in un’unica riga). Il gruppo 1 si ferma prima del primo spazio perché il carattere dello spazio non è stato incluso nei criteri di ricerca. I gruppi 2 e 4 sono semplicemente lo spazio bianco, che in questo caso è letteralmente un carattere di spazio, ma potrebbe anche essere una tabulazione o un avanzamento di riga, ecc. Il gruppo 3 include lo spazio perché lo inserisco nei criteri di ricerca … ecc.

Spero che questo abbia un senso.

Parentesi () vengono utilizzate per abilitare il raggruppamento di frasi regex.

Il group(1) contiene la stringa tra parentesi (.*) Così .* In questo caso

E il group(0) contiene un’intera stringa abbinata.

Se avessi più gruppi (leggi (...) ), verrebbe inserito in gruppi con gli indici successivi (2, 3 e così via).