Continuiamo il nostro studio sulle espressioni regolari. In questo articolo esamineremo le classi di caratteri predefinite e la quantificazione (ricerca di sequenze).
Classi di caratteri predefinite
L'API di classe Patterncontiene classi di caratteri predefinite che offrono comode scorciatoie alle espressioni regolari di uso comune. In questa tabella, i costrutti nella colonna di sinistra sono rappresentazioni abbreviate delle espressioni nella colonna di destra. Ad esempio, \dsignifica un numero (0-9), \wsignifica qualsiasi lettera maiuscola o minuscola, un carattere di sottolineatura o un numero). Utilizza classi di caratteri predefinite quando possibile. Ciò renderà il tuo codice più facile da leggere e correggerà gli errori. I costrutti che iniziano con una barra rovesciata sono chiamati escape o protetti. Negli articoli precedenti abbiamo già parlato dell'escape dei caratteri speciali con barre rovesciate o simboli \Qe \Edel loro utilizzo come caratteri normali. Se utilizzi una barra rovesciata con caratteri regolari (letterali), devi eseguire l'escape della barra rovesciata affinché l'espressione possa essere compilata.
privatefinalString REGEX ="\\d";// цифра
In questo esempio \d, un'espressione regolare; la barra rovesciata aggiuntiva è necessaria per la compilazione del programma. Il nostro programma di test legge le espressioni regolari direttamente dalla console, quindi non è necessaria alcuna barra aggiuntiva. L'esempio seguente dimostra l'uso di classi di caratteri predefinite: Nei primi tre esempi, l'espressione regolare è semplicemente " ." (il carattere speciale punto), che significa qualsiasi carattere. Pertanto la ricerca ha avuto esito positivo in tutti i casi. Altri esempi utilizzano classi di caratteri predefinite, i cui significati abbiamo discusso nella tabella sopra.
Quantificatori
I quantificatori consentono di specificare il numero di occorrenze di un carattere in una stringa. Diamo uno sguardo più da vicino alle complessità del funzionamento dei quantificatori avidi, pigri e molto avidi. A prima vista può sembrare che i quantificatori X?, X?? e X?+ funzionano allo stesso modo: “X è presente una volta o non è presente affatto”. Esistono lievi differenze nell'implementazione di questi quantificatori, che esamineremo di seguito.
Corrispondenze di lunghezza zero
Cominciamo con quello goloso. Scriviamo tre diverse espressioni regolari: la lettera “a” con i caratteri speciali ?, * o +. Vediamo cosa succede se testiamo queste espressioni regolari su una riga vuota: Nell'esempio sopra, la ricerca ha avuto successo nei primi due casi, perché le espressioni a? e a* consentono la mancanza del carattere a nella stringa. Si noti inoltre che l'indice di inizio e quello dell'ultima corrispondenza sono gli stessi (0). Poiché la stringa di input non ha lunghezza, il programma non trova nulla :) nella prima posizione. Questo caso è chiamato corrispondenza di lunghezza zero. Tali corrispondenze si verificano in diversi casi: quando la riga di input è vuota, all'inizio della riga di input, dopo l'ultimo carattere della riga o tra i caratteri della riga. Le partite di durata zero sono facili da individuare: iniziano e finiscono nella stessa posizione. Diamo un'occhiata ad altri esempi di corrispondenze di lunghezza zero. Esploriamo le partite di durata zero con qualche altro esempio. Cambiamo la stringa di input nel carattere "a" e osserviamo un effetto interessante: tutti e tre i quantificatori hanno trovato il carattere "a", ma i primi due, che consentono l'assenza di un carattere, hanno trovato una corrispondenza di lunghezza zero nella posizione 1 - dopo l'ultimo carattere della stringa. Ciò accade perché il programma tratta il carattere "a" come una stringa e lo "percorre" finché non ci sono più corrispondenze. A seconda del quantificatore utilizzato, il programma troverà o meno "niente" alla fine della stringa. Ora cambiamo la stringa di input in una sequenza di cinque lettere "a": Espressione regolare a? trova una corrispondenza per ogni lettera nella stringa separatamente. L'espressione a* trova due corrispondenze: la sequenza di caratteri "a"' e una corrispondenza di lunghezza zero nella posizione 5. E infine, l'espressione regolare a+ trova solo la sequenza di caratteri “a”, senza trovare “niente” :) Cosa accadrà se viene fornita come input una stringa contenente caratteri diversi? Ad esempio, "ababaaaab": il carattere "b" è nelle posizioni 1, 3 e 8 e il programma trova corrispondenze di lunghezza zero in queste posizioni. Espressione regolare a? non presta attenzione alla "b", ma cerca semplicemente la presenza (o l'assenza) del carattere "a". Se il quantificatore consente l'assenza di "a", tutti i caratteri nella stringa diversi da "a" verranno visualizzati come corrispondenze di lunghezza zero. Per trovare sequenze di una determinata lunghezza, è sufficiente specificare la lunghezza tra parentesi graffe: l'espressione regolare a{3} cerca una sequenza di tre caratteri "a". Non è stato trovato nulla nella prima riga perché non c'erano abbastanza "a" nella riga. Il secondo contiene 3 caratteri, che il programma trova. Anche il terzo test trova una corrispondenza all'inizio della stringa. Tutto dopo il terzo carattere non soddisfa l'espressione regolare, nel codice seguente lo fa e ci saranno diverse corrispondenze: Per specificare la lunghezza minima della sequenza, utilizzare:
Enter your regex: a{3,}Enter input string tosearch: aaaaaaaaa
I found the text "aaaaaaaaa" starting at index 0 and ending at index 9.
In questo esempio, il programma trova solo una corrispondenza perché la stringa soddisfa il requisito di lunghezza minima della sequenza di (3) caratteri "a". Infine, impostando la lunghezza massima della sequenza: in questo esempio, la prima corrispondenza termina con il sesto carattere. La seconda corrispondenza contiene caratteri successivi alla sesta, perché soddisfano il requisito di lunghezza minima. Se la stringa fosse più corta di un carattere, non ci sarebbe una seconda corrispondenza.
Utilizzo di gruppi e classi di caratteri con quantificatori
Fino a questo punto abbiamo testato i quantificatori su stringhe contenenti lo stesso carattere. I quantificatori si applicano solo a un singolo carattere, quindi l'espressione regolare "abc+" corrisponderà alle stringhe contenenti "ab" e "c" una o più volte. Non significherà "abc" una o più volte. Ma i quantificatori possono essere usati insieme a gruppi e classi di caratteri, come [abc]+ (a o b o c, una o più volte) o (abc)+ (“abc” una o più volte). Troviamo un gruppo di caratteri (cane), tre volte in una riga: Nel primo esempio il programma trova una corrispondenza, perché il quantificatore si estende a un gruppo di caratteri. Se rimuovi le parentesi, il quantificatore {3} si applicherà solo alla lettera "g". Puoi anche utilizzare quantificatori con classi di caratteri: il quantificatore {3} si applica alla classe di caratteri tra parentesi nel primo esempio e nel secondo solo al carattere "c".
Differenze tra quantificatori greedy, pigri e over-greedy
Ci sono lievi differenze tra i quantificatori avidi, riluttanti e possessivi. I quantificatori golosi sono così chiamati perché cercano di trovare la corrispondenza più lunga possibile: il programma prima tenta di "mangiare" l'intera stringa, se non viene trovata una corrispondenza, viene scartato un carattere e la ricerca viene ripetuta finché non viene trovata una corrispondenza o non rimangono più personaggi. Le persone pigre, invece, iniziano dall'inizio della riga, aggiungendo carattere dopo carattere finché non trovano una corrispondenza. Infine, la quantificazione gelosa scansiona l'intera stringa una volta, senza rimuovere caratteri come in greedy. Per dimostrazione useremo la stringa xfooxxxxxxfoo. Il primo esempio utilizza il quantificatore greedy .* per trovare qualsiasi carattere, 0 o più volte, seguito dai caratteri "f" "o" "o". Poiché il cantifier è avido, la corrispondenza trovata contiene l'intera stringa. Un quantificatore avido non troverà tutte le corrispondenze in una stringa perché nel primo passaggio, dopo aver scansionato l'intera stringa, troverà una corrispondenza e terminerà il lavoro. Il secondo esempio è pigro e inizia dall'inizio della riga, aggiungendo carattere per carattere. Il programma inizia controllando il "vuoto", ma da allora la sequenza "foo" non è all'inizio della riga, la ricerca prosegue con l'aggiunta del carattere "x", dopodiché verrà trovata la prima corrispondenza tra gli indici 0 e 4. La ricerca prosegue fino alla fine della riga e la seconda corrispondenza verrà trovata tra gli indici 4 e 13. Il terzo esempio non trova coincidenze perché il quantificatore è geloso. In questo caso, l'espressione regolare .*+ "ha mangiato" l'intera riga, senza lasciare nulla per "foo". Usa il quantificatore geloso quando devi scartare qualcosa di non necessario in una stringa, sarà più efficace del quantificatore goloso equivalente. È tutto! Link alla fonte: Nozioni di base sulle espressioni regolari in Java. Parte 3
Nei primi tre esempi, l'espressione regolare è semplicemente " 
I quantificatori consentono di specificare il numero di occorrenze di un carattere in una stringa. Diamo uno sguardo più da vicino alle complessità del funzionamento dei quantificatori avidi, pigri e molto avidi. A prima vista può sembrare che i quantificatori X?, X?? e X?+ funzionano allo stesso modo: “X è presente una volta o non è presente affatto”. Esistono lievi differenze nell'implementazione di questi quantificatori, che esamineremo di seguito.
Nell'esempio sopra, la ricerca ha avuto successo nei primi due casi, perché le espressioni a? e a* consentono la mancanza del carattere a nella stringa. Si noti inoltre che l'indice di inizio e quello dell'ultima corrispondenza sono gli stessi (0). Poiché la stringa di input non ha lunghezza, il programma non trova nulla :) nella prima posizione. Questo caso è chiamato corrispondenza di lunghezza zero. Tali corrispondenze si verificano in diversi casi: quando la riga di input è vuota, all'inizio della riga di input, dopo l'ultimo carattere della riga o tra i caratteri della riga. Le partite di durata zero sono facili da individuare: iniziano e finiscono nella stessa posizione. Diamo un'occhiata ad altri esempi di corrispondenze di lunghezza zero. Esploriamo le partite di durata zero con qualche altro esempio. Cambiamo la stringa di input nel carattere "a" e osserviamo un effetto interessante: 
tutti e tre i quantificatori hanno trovato il carattere "a", ma i primi due, che consentono l'assenza di un carattere, hanno trovato una corrispondenza di lunghezza zero nella posizione 1 - dopo l'ultimo carattere della stringa. Ciò accade perché il programma tratta il carattere "a" come una stringa e lo "percorre" finché non ci sono più corrispondenze. A seconda del quantificatore utilizzato, il programma troverà o meno "niente" alla fine della stringa. Ora cambiamo la stringa di input in una sequenza di cinque lettere "a": 
Espressione regolare a? trova una corrispondenza per ogni lettera nella stringa separatamente. L'espressione a* trova due corrispondenze: la sequenza di caratteri "a"' e una corrispondenza di lunghezza zero nella posizione 5. E infine, l'espressione regolare a+ trova solo la sequenza di caratteri “a”, senza trovare “niente” :) Cosa accadrà se viene fornita come input una stringa contenente caratteri diversi? Ad esempio, "ababaaaab": 
il carattere "b" è nelle posizioni 1, 3 e 8 e il programma trova corrispondenze di lunghezza zero in queste posizioni. Espressione regolare a? non presta attenzione alla "b", ma cerca semplicemente la presenza (o l'assenza) del carattere "a". Se il quantificatore consente l'assenza di "a", tutti i caratteri nella stringa diversi da "a" verranno visualizzati come corrispondenze di lunghezza zero. Per trovare sequenze di una determinata lunghezza, è sufficiente specificare la lunghezza tra parentesi graffe: 
l'espressione regolare a{3} cerca una sequenza di tre caratteri "a". Non è stato trovato nulla nella prima riga perché non c'erano abbastanza "a" nella riga. Il secondo contiene 3 caratteri, che il programma trova. Anche il terzo test trova una corrispondenza all'inizio della stringa. Tutto dopo il terzo carattere non soddisfa l'espressione regolare, nel codice seguente lo fa e ci saranno diverse corrispondenze: 
Per specificare la lunghezza minima della sequenza, utilizzare:
in questo esempio, la prima corrispondenza termina con il sesto carattere. La seconda corrispondenza contiene caratteri successivi alla sesta, perché soddisfano il requisito di lunghezza minima. Se la stringa fosse più corta di un carattere, non ci sarebbe una seconda corrispondenza.
Nel primo esempio il programma trova una corrispondenza, perché il quantificatore si estende a un gruppo di caratteri. Se rimuovi le parentesi, il quantificatore {3} si applicherà solo alla lettera "g". Puoi anche utilizzare quantificatori con classi di caratteri: 
il quantificatore {3} si applica alla classe di caratteri tra parentesi nel primo esempio e nel secondo solo al carattere "c".
Il primo esempio utilizza il quantificatore greedy .* per trovare qualsiasi carattere, 0 o più volte, seguito dai caratteri "f" "o" "o". Poiché il cantifier è avido, la corrispondenza trovata contiene l'intera stringa. Un quantificatore avido non troverà tutte le corrispondenze in una stringa perché nel primo passaggio, dopo aver scansionato l'intera stringa, troverà una corrispondenza e terminerà il lavoro. Il secondo esempio è pigro e inizia dall'inizio della riga, aggiungendo carattere per carattere. Il programma inizia controllando il "vuoto", ma da allora la sequenza "foo" non è all'inizio della riga, la ricerca prosegue con l'aggiunta del carattere "x", dopodiché verrà trovata la prima corrispondenza tra gli indici 0 e 4. La ricerca prosegue fino alla fine della riga e la seconda corrispondenza verrà trovata tra gli indici 4 e 13. Il terzo esempio non trova coincidenze perché il quantificatore è geloso. In questo caso, l'espressione regolare .*+ "ha mangiato" l'intera riga, senza lasciare nulla per "foo". Usa il quantificatore geloso quando devi scartare qualcosa di non necessario in una stringa, sarà più efficace del quantificatore goloso equivalente. È tutto! Link alla fonte: Nozioni di base sulle espressioni regolari in Java. Parte 3
GO TO FULL VERSION