Regular Expression

Espressioni regolari

1

Regular Expression

Pagina intenzionalmente bianca

2

Regular Expression

Java: Espressioni regolarihttp://www.nerthase.com/blog/java-espressioni-regolariVi ho già parlato delle espressioni regolari e di come verificare il corretto funzionamento di esse in modo veloce con Regex Tester. Ora vediamo invece come usare in maniera semplice e veloce le espressioni regolari nei nostri programmi Java. Innanzitutto ricordiamo che un’espressione regolare, è necessaria nel caso in cui vogliamo catturare o identificare le occorrenze di una certa forma o struttura all’interno di un contesto più ampio. Esistono alcuni identificatori particolari nelle espressioni regolari per identificare insiemi di caratteri:

• \d Carattere numerico • \D Carattere NON numerico • \s Spazio • \S Carattere diverso dallo spazio • \w Carattere alfanumerico • \W Carattere speciale (non alfanumerico)

Ricordiamo che in Java il carattere \ è un carattere speciale, e quindi per usarlo dobbiamo inserire \\.

Vediamo ora alcuni esempi di espressioni regolari, per chiarire meglio alcuni concetti. Per verificare la presenza di un indirizzo email all’interno di un testo, usiamo l’espressione regolare:

[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}

Se invece vogliamo estrapolare il codice fiscale di una persona dal suo Curriculum Vitae, ad esempio, possiamo usare:

[a-zA-Z]{6}\d\d[a-zA-Z]\d\d[a-zA-Z]\d\d\d[a-zA-Z]

In maniera del tutto analoga, vediamo l’espressione regolare utilizzabile per catturare un URL (questa l’ho usata molto spesso):

http\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?

Queste espressioni regolari di sopra, non possono essere riportate direttamente in Java, perché si deve inserire un carattere \ prima dei caratteri speciali che Java interpreterebbe in modo errato.

3

Regular Expression

Le classi che vengono usate in Java per le espressioni regolari sono sostanzialmente due:

• java.util.regex.Pattern rappresenta l’espressione regolare. Può essere istanziato un oggetto di questa classe fornendo come parametro l’espressione regolare.

• java.util.regex.Matcher è la classe che identifica le occorrenze dell’espressione regolare all’interno di un testo.

Ma veniamo agli esempi pratici. Nell’esempio che segue cerchiamo all’interno della stringa input tutti gli indirizzi email che compaiono:

// Testo di input

String input = "Un indirizzo di email può essere fatto così: prova@email.it oppure in questo modo: tuonome@dominio.com o ancora in mille modi diversi.";

// Espressione regolare - Notare l'inserimento di \\ al posto di un solo \

String regex = "[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}";

// Compilo l'espressione regolare e creo l'oggetto Matcher

Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);

// matcher.find() restituisce true fino a che ci sono match validi nella stringa di input

// matcher.group() restituisce il testo che ha causato il precedente matchwhile (matcher.find()) System.out.println(matcher.group());

http://java.html.it/articoli/leggi/2787/espressioni-regolari-in-java/Le espressioni regolari rappresentano uno strumento molto potente per lavorare sulle stringhe. Possono essere utilizzate, sia per convalidare i dati, sia per effettuare ricerche all'interno di un testo. La sintassi di questo pseudo-linguaggio è molto flessibile e consente di creare espressioni in base alle proprie esigenze.

Dalla versione 1.4 di Java (in linea con quanto fatto già da PHP, javascript, Ruby e altri), è stato introdotto il package java.util.regex composto dalle classi Pattern e Matcher che permettono di validare una stringa, o ricercare un testo al suo interno, a partire da un'espressione regolare.

4

Regular Expression

Per definire un'espressione regolare è necessario conoscere alcune regole base:• […] Insieme di caratteri validi; • [^...] Insieme negato di caratteri validi; • - Intervallo; • && Intersezione; • . Qualunque carattere; • + Concatenazione; • RE* Cardinalità multipla (0 o più occorrenze dell'espressione RE); • RE{n} Cardinalità multipla (esattamente n occorrenze dell'espressione RE); • RE{n,} Cardinalità multipla (almeno n occorrenze dell'espressione RE); • RE{n,m} Cardinalità multipla (almeno n occorrenze dell'espressione RE, ma

non più di m).

Facciamo alcuni esempi semplici per chiarire meglio le regole:• [abc] Espressione che contiene un solo carattere tra a, b, o c; • [^abc] Espressione che contiene un solo carattere, tutti sono validi, ad

esclusione di a, b, o c; • [a-z] Espressione che contiene un solo carattere tra quelli del range a-z; • [a-d[m-p]] Espressione che contiene un solo carattere tra quelli del range a-d e

del range m-p (unione); • [a-z&&[def]] Espressione che contiene un solo carattere tra quelli comuni del

range a-z e dell'insieme (d, e, f) (intersezione); • [a-z&&[^bc]] Espressione che contiene un solo carattere tra quelli comuni del

range a-z e dell'insieme negato (b, f) (intersezione); • [a-z&&[^m-p]] Espressione che contiene un solo carattere tra quelli comuni

del range a-z e del range negato (m-p) (intersezione).

Esistono anche forme abbreviate per rappresentare un insieme di caratteri. Ad esempio:

• \d Carattere numerico. Corrisponde all'insieme [0-9]; • \D Carattere diverso da un numero. Corrisponde all'insieme [^0-9]; • \s Carattere spazio; • \S Carattere diverso dallo spazio. Corrisponde all'insieme [^\s]; • \w Parola alfanumerica. Corrisponde all'insieme [a-zA-Z_0-9]; • \W Parola costituita da caratteri speciali. Corrisponde all'insieme [^\w].

5

Regular Expression

Di seguito riportiamo alcune espressioni comunemente utilizzate:

indirizzo email[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}

data in formato dd/mm/aaaa(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[-/.](19|20)\d\d

url httphttp\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?

codice fiscale[a-zA-Z]{6}\d\d[a-zA-Z]\d\d[a-zA-Z]\d\d\d[a-zA-Z]

Adesso che abbiamo i requisiti indispensabili per scrivere un'espressione regolare, vediamo come utilizzare il package java.util.regex per validare le nostre stringhe o ricercare del testo al loro interno.

Le classi principali del package sono le seguenti:• java.util.regex.Pattern rappresenta l'espressione regolare effettiva. Per

ottenere un'istanza della classe Pattern, è necessario invocare il metodo statico compile che accetta come parametro una stringa che rappresenta l'espressione regolare. La classe Pattern dispone anche del metodo statico matches che riceve in input due stringhe, la prima è l'espressione regolare, la seconda è la stringa da validare. Il metodo restituisce un booleano, true se la stringa rispetta il formato, false altrimenti.

• java.util.regex.Matcher è il motore che interpreta i pattern ed esegue le operazioni di match sulla stringa data. Per ottenere un'istanza della classe Matcher, è necessario invocare il metodo statico matcher su un'istanza dell'oggetto Pattern.

• java.util.regex.PatternSyntaxException è l'eccezione che viene sollevata nel momento in cui viene individuato un errore di sintassi nel pattern di una espressione regolare.

6

Regular Expression

Per verificare se una stringa rispetta il formato definito dall'espressione regolare possiamo utilizzare due metodi. Nel primo caso utilizziamo il metodo statico matches della classe Pattern, passandogli l'espressione regolare e la stringa da validare:

public static boolean check(String regex, String input){ if (Pattern.matches(regex, input)) return true; else return false;}

Nel secondo caso creiamo prima un'istanza della classe Matcher e poi richiamiamo il metodo matcher.

public static boolean check(String regex, String input){ Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input);

if (matcher.matches()) return true; else return false;}

È possibile, inoltre, utilizzare il package java.util.regex per ricercare una stringa all'interno di un'altra.

String regex = "[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}";String input = "pippo@email.it;pluto@email.it;paperino@email.it";

Pattern pattern = Pattern.compile(regex);Matcher matcher = pattern.matcher(input);

while (matcher.find())System.out.println(matcher.group());

7

Regular Expression

Il metodo find della classe Matcher, ricerca una sottostringa all'interno della stringa di ingresso che rispetta il formato dell'espressione regolare. Il metodo find funziona come un iterator, cioè aggiorna gli indici ad ogni iterazione. Se eseguiamo l'esempio otterremo come output:

pippo@email.itpluto@email.itpaperino@email.it

8

Regular Expression

Espressione regolareDa Wikipedia, l'enciclopedia libera.Una espressione regolare (in inglese regular expression o, in forma abbreviata, regexp, regex o RE) è una sequenza di simboli (quindi una stringa) che identifica un insieme di stringhe. Programmi diversi supportano notazioni diverse per esprimere le stesse espressioni regolari, nel senso che non esiste una sintassi "universale".

Le espressioni regolari sono generalmente usate per definire linguaggi regolari, tuttavia permettono di definire anche linguaggi non regolari. I linguaggi regolari sono i linguaggi generati da grammatiche di tipo 3 (nella gerarchia di Chomsky) e riconosciuti da automi a stati finiti.

Indice• 1 Definizione • 2 Storia • 3 Espressioni regolari nei linguaggi formali • 4 Impiego delle espressioni regolari • 5 Sintassi

• 5.1 Espressioni regolari tradizionali di UNIX • 5.2 Esempi di quantificatori

• 6 Note • 7 Bibliografia • 8 Voci correlate • 9 Altri progetti • 10 Collegamenti esterni

Definizione Una espressione regolare definisce una funzione che prende in ingresso una stringa, e restituisce in uscita un valore del tipo sì/no, a seconda che la stringa segua o meno un certo pattern. Ad esempio, tutti gli indirizzi e-mail devono essere costituiti nel seguente modo: cominciare con una sequenza di caratteri alfanumerici, seguiti dal simbolo chiocciola, seguiti da altri caratteri alfanumerici, seguiti dal punto, seguiti da due o tre lettere.[1] Questa regola informale diventerebbe una regex qualora fosse codificata secondo una sintassi ben precisa e riconosciuta da un programma in grado di analizzare le stringhe.

9

Regular Expression

Storia Sebbene fossero state formalizzate già fin dagli anni quaranta, le espressioni regolari entrarono nel mondo informatico per la prima volta alla fine degli anni sessanta, in ambiente Unix: il primo editor di testo che implementava delle funzioni che ne permettessero l'uso fu una versione di QED scritta da Ken Thompson, uno dei pionieri di Unix. L'editor, dalla sua interfaccia a riga di comando, metteva a disposizione un comando chiamato global regular expression print, che successivamente fu reso un applicativo indipendente, grep.

Le espressioni regolari non ebbero grande diffusione ed utilizzo fino agli anni ottanta, quando fu inventato il linguaggio di programmazione Perl che permetteva nativamente l'uso di espressioni regolari. La versatilità del linguaggio, dovuta anche al fatto d'essere un linguaggio interpretato, ne permise l'utilizzo in svariate situazioni e favorì lo sviluppo del formalismo di Perl per le espressioni regolari, che diventò uno standard de facto.

La grandissima diffusione di questi strumenti spinse alcuni sviluppatori a implementare le espressioni regolari anche in altri linguaggi, a mezzo di librerie come PCRE o persino come parte delle librerie standard di alcuni linguaggi, come Java e tcl.

Attualmente[quando?] le espressioni regolari sono disponibili nella maggioranza degli editor di testo per GNU/Linux e altri sistemi unix-like.

Espressioni regolari nei linguaggi formali Le espressioni regolari sono composte da costanti e operatori che denotano insiemi di stringhe, e da operazioni tra questi insiemi.Dato un alfabeto finito Σ , sono definite le seguenti costanti:

1. ∅ (insieme vuoto) 2. ϵ (stringa vuota, ovvero la stringa di lunghezza 0) 3. { a } (carattere, ∀a∈Σ )

e le seguenti operazioni:1. concatenazione: RS o R o S indica l'insieme αβ/α∈R∧β∈S 2. unione: R∪S indica l'unione dei due insiemi 3. stella di Kleene : R* indica l'insieme che contiene tutte le possibili iterazioni

ottenibili dagli elementi di R 4. intersezione: R∩S indica l'intersezione tra i due insiemi di stringhe 5. complemento: il complementare di R indica l'insieme delle stringhe

appartenenti a Σ* \ R

10

Regular Expression

Ad esempio dati R={ a ,b } e S={7, 8} , RS={ a7 , b7 , a8 ,b8 } eS *={ ϵ ,7 ,8 ,77 ,78 ,87,88 ,777 ,778 ,... } . Allora, possiamo dire che un'espressione

regolare, definita a partire da un alfabeto ed un insieme di simboli{ , + ,* , ( , ) , . ,∅ ,} , è una stringa R∈(Σ∪{ +,*,(,),.,∅ ,})+ che rende vera

alcuna delle seguenti condizioni:1. R=∅2. R∈Σ3. R=S+T o R=ST o R=S * , dove S e T sono espressioni regolari

sull'alfabeto Σ

Impiego delle espressioni regolari Le espressioni regolari sono utilizzate principalmente da editor di testo per la ricerca e la sostituzione di porzioni del testo. Grande importanza rivestono inoltre nell'informatica teorica, nella quale, ad esempio, sono utilizzate per rappresentare tutti i possibili cammini su un grafo. Tuttavia, le espressioni regolari sono adatte a rappresentare un ristrettissimo insieme di linguaggi formali (se volessimo rappresentare espressioni aritmetiche o linguaggi di programmazione, avremmo già bisogno di utilizzare linguaggi di tipo 2): l'utilizzo dei linguaggi regolari è comunque conveniente, in quanto la chiusura degli stessi alle operazioni di unione, intersezione e complementazione, permettono la costruzione di un'algebra di Boole ed una buona capacità decisionale.

Sintassi

Espressioni regolari tradizionali di UNIX La sintassi di base delle espressioni regolari in UNIX è attualmente definita obsoleta[non chiaro] dallo standard POSIX, ma è comunque molto usata a causa della sua diffusione. La maggior parte dei programmi che utilizzano le regexp, come grep e sed, utilizzano tali regole di base fornendo al contempo supporto per le nuove regole estese. In questa sintassi, la maggior parte dei caratteri sono visti come letterali, e trovano solo se stessi ("a" trova "a", "bc)" trova "bc)" ecc.). Le eccezioni a questa regola sono i metacaratteri:

11

Regular Expression

. Trova un singolo carattere (se è nella modalità linea singola altrimenti se è in multiriga prende tutti i caratteri diversi da \n, ovvero un ritorno a capo).

[ ] Trova un singolo carattere contenuto nelle parentesi. Ad esempio, [abc] trova o una "a", "b", o "c". [a-z] è un intervallo e trova ogni lettera minuscola dell'alfabeto. Possono esserci casi misti: [abcq-z] trova a, b, c, q, r, s, t, u, v, w, x, y, z, esattamente come [a-cq-z]. Il carattere '-' è letterale solo se è primo o ultimo carattere nelle parentesi: [abc-] o [-abc]. Per trovare un carattere '[' o ']', il modo più semplice è metterli primi all'interno delle parentesi: [][ab] trova ']', '[', 'a' o 'b'.

[^ ] Trova ogni singolo carattere non incluso nelle parentesi. Ad esempio, [^abc] trova ogni carattere diverso da "a", "b", o "c". [^a-z] trova ogni singolo carattere che non sia una lettera minuscola. Come sopra, questi due metodi possono essere usati insieme.

^ Corrisponde all'inizio della stringa (o di ogni riga della stringa, quando usato in modalità multilinea)

$ Corrisponde alla fine della stringa o alla posizione immediatamente precedente un carattere di nuova linea (o alla fine di ogni riga della stringa, quando usato in modalità multilinea)

( ) Definisce una "sottoespressione marcata". Il risultato di ciò che è incluso nell'espressione, può essere richiamato in seguito. Vedi sotto, \n.

\n Dove n è una cifra da 1 a 9; trova ciò che la nesima sottoespressione ha trovato. Tale costrutto, detto backreference, estende le potenzialità delle regexp oltre i linguaggi regolari e non è stato adottato nella sintassi estesa delle regexp.

* • Un'espressione costituita da un singolo carattere seguito da "*", trova zero o più copie di tale espressione. Ad esempio, "[xyz]*" trova "", "x", "y", "zx", "zyx", e così via.

• \n*, dove n è una cifra da 1 a 9, trova zero o più iterazioni di ciò che la nesima sottoespressione ha trovato. Ad esempio, "(a.)c\1*" trova "abcab" e "accac" ma non "abcac".

• Un'espressione racchiusa tra "\(" e "\)" seguita da "*" non è valida. In alcuni casi (es. /usr/bin/xpg4/grep di SunOS 5.8), trova zero o più ripetizioni della stringa che l'espressione racchiusa ha trovato. In altri casi (es. /usr/bin/grep di SunOS 5.8), trova ciò che l'espressione racchiusa ha trovato, seguita da un letterale "*".

{x,y} Trova l'ultimo "blocco" almeno x volte e non più di y volte. Ad esempio, "a{3,5}" trova "aaa", "aaaa" o "aaaaa".

12

Regular Expression

Vecchie versioni di grep non supportano il separatore alternativo "|".Esempi:

".atto" trova ogni stringa di cinque caratteri come gatto, matto o patto "[gm]atto" trova gatto e matto "[^p]atto" trova tutte le combinazioni dell'espressione ".atto" tranne patto "^[gm]atto" trova gatto e matto ma solo all'inizio di una riga "[gm]atto$" trova gatto e matto ma solo alla fine di una riga

Dal momento che molte serie di caratteri variano a seconda della configurazione locale (in alcuni casi le lettere sono organizzate in abc..xyzABC...XYZ, in altri aAbB..yYzZ), lo standard POSIX ha definito alcune classi o categorie di caratteri come mostrato nella seguente tabella:

classe POSIX

sintassi normale significato

[:upper:] [A-Z] lettere maiuscole[:lower:] [a-z] lettere minuscole[:alpha:] [A-Za-z] lettera sia maiuscole che minuscole[:alnum:] [A-Za-z0-9] numeri e lettere maiuscole e minuscole[:digit:] [0-9] numeri[:xdigit:] [0-9A-Fa-f] numeri in formato esadecimale[:punct:] [.,!?:...] segni di interpunzione[:blank:] [ \t] spazio o TAB[:space:] [ \t\n\r\f\v] caratteri vuoti[:cntrl:] caratteri control[:graph:] [^ \t\n\r\f\v] caratteri non vuoti[:print:] [^\t\n\r\f\v] caratteri non vuoti e spaziLe parentesi quadrate fanno parte della sintassi per indicare la classe di caratteri. Ad esempio [[:upper:][:digit:]ab] trova corrispondenza in una qualsiasi lettera maiuscola, in una qualsiasi cifra, nella lettera 'a' minuscola e nella lettera 'b' minuscola.

13

Regular Expression

Esempi di quantificatori • * Cerca l'occorrenza (zero o più volte) del carattere o insieme di caratteri cui

segue: abc* identifica ab seguito da zero o più c come in ab, abc, abcc, abccc

• + Cerca l'occorrenza (una o più volte) del carattere o insieme di caratteri cui segue:

ab[ce]+ identifica ab seguito da una o più c oppure una o più e come in abc, abec, abccc, abcceeecccccce

• ? Cerca l'occorrenza (zero o una volta) del carattere o insieme di caratteri cui segue:

abc? identifica ab seguito o meno da una c come in abc e ab

• {m, n} Cerca l'occorrenza (da m a n volte; m lasciato vuoto è zero, n lasciato vuoto infinito) del carattere, insieme di caratteri o sotto-regex cui segue:

(ab){1,2} identifica le sequenze di uno o due ab come in ab e abab

14

Regular Expression

Espressioni RegolariJava Tutorial

15

Regular Expression

http://docs.oracle.com/javase/tutorial/essential/regex/index.html

16

Regular Expression

IntroduzioneLe espressioni regolari sono un modo per descrivere un insieme di stringhe in base a caratteristiche comuni condivise da ogni stringa nell'insieme. Possono essere utilizzate per cercare, modificare, o manipolare testo e dati. Dovete imparare una sintassi specifica per creare espressioni regolari - cosa che va al di là della normale sintassi del linguaggio di programmazione Java. Le espressioni regolari variano per complessità, ma una volta capite le basi di come sono costruite, sarete in grado di decifrare (o creare) una qualsiasi espressione regolare.

Questo percorso insegna la sintassi delle espressioni regolari supportati dalle API java.util.regex e presenta diversi esempi di lavoro per illustrare come i vari oggetti interagiscono. Nel mondo delle espressioni regolari, ci sono molti gusti diversi tra cui scegliere, come grep, Perl, Tcl, Python, PHP, e awk. La sintassi delle espressioni regolari in API java.util.regex è più simile a quello trovato in Perl.

Come sono le espressioni regolari rappresentati in questo pacchetto?Il pacchetto java.util.regex è costituito principalmente da tre classi: Pattern, Matcher, e PatternSyntaxException.

• Un oggetto Pattern compilato è una rappresentazione di una espressione regolare. La classe modello non fornisce costruttori pubblici. Per creare un modello, è necessario innanzitutto richiamare uno dei suoi metodi pubblici di compilazione statici, che poi restituiscono un oggetto Pattern. Questi metodi accettano un'espressione regolare come primo argomento, le prime lezioni di questo percorso vi insegneranno la sintassi richiesta.

• Un oggetto Matcher è il motore che interpreta il modello ed esegue le operazioni di confronto con una stringa di input. Come la classe Pattern, Matcher non definisce costruttori pubblici. Si ottiene un oggetto Matcher richiamando il metodo matcher su un oggetto Pattern.

• Un oggetto PatternSyntaxException è un'eccezione unchecked che indica un errore di sintassi in un modello di espressione regolare.

Occorrono poche lezioni, in questo percorso, ad esplorare ogni classe nel dettaglio. Ma prima è necessario capire come le espressioni regolari sono effettivamente costruite. Pertanto, la sezione successiva presenta un semplice test che verrà utilizzato ripetutamente per esplorare la loro sintassi.

17

Regular Expression

test HarnessQuesta sezione definisce un test riutilizzabile, RegexTestHarness.java, per esplorare l'espressione regolare supportata da questa API. Il comando per eseguire questo codice è RegexTestHarness java, gli argomenti della riga di comando non sono accettati. L'applicazione itera più volte, chiedendo all'utente di un'espressione regolare e la stringa di input. L'utilizzo di questo test harness è facoltativo, ma può risultare conveniente per esplorare i casi di test discussi nelle pagine seguenti. Per terminare premere CTRL ^C.

import java.io.Console;import java.util.regex.Pattern;import java.util.regex.Matcher;

public class RegexTestHarness { public static void main(String[] args) { Console console = System.console(); if (console == null) { System.err.println("No console."); System.exit(1); } while (true) { Pattern pattern = Pattern.compile(console.readLine("%nEnter your regex: "));

Matcher matcher = pattern.matcher(console.readLine("Enter input string to search: "));

boolean found = false; while (matcher.find()) { console.format("I found the text" + " \"%s\" starting at " + "index %d and ending at index %d.%n", matcher.group(), matcher.start(), matcher.end()); found = true; } if(!found) { console.format("No match found.%n"); } } }}

Prima di proseguire alla sezione successiva, salvare e compilare il codice per rendere il vostro ambiente di sviluppo supporta i pacchetti richiesti.

18

Regular Expression

Qui di seguito riportiamo il testo del programma di test delle classi pattern e matcher del package java.util.regex. Il programma e una versione modificata di quello preso dal tutorial della Sun: e stato eliminato l'utilizzo della classe Console in quanto funzionante solo su Java versione 6 (e al laboratorio è installata la versione 5) e i messaggi di interazione con l'utente sono stati tradotti in italiano.

import java.io.*;import java.util.regex.Pattern;import java.util.regex.Matcher;public class RegexTestHarness {

public static void main ( String [ ] args ) throws IOException {BufferedReader in=new BufferedReader (new InputStreamReader(System.in));while(true){

System.out.println("Inseriscil'espressione regolare: ");Pattern pattern =Pattern.compile(in.readLine ( ) ) ;System.out.println("Inserisci la stringa nella quale effettuare la ricerca:");Matcher matcher =pattern.matcher(in.readLine());boolean found = false ;while (matcher.find()) {

System.out.println("Ho trovato il testo "+matcher.group()+"a partire dalla posizione"+matcher.start()+"fino alla posizione "+matcher.end());found = true ;

}if(!found){

System.out.println("Nessuna corrispondenza trovata." ) ; } }

}}

dal file esercitazioneRE.pdf

19

Regular Expression

Stringhe letteraliLa forma più semplice di pattern matching supportato da questa API è il confronto di una stringa letterale. Ad esempio, se l'espressione regolare è foo e la stringa di input è foo, il confronto avrà successo, perché le stringhe sono identiche. Provate ciò con il test harness:

Inserisci il tuo regex: fooInserisci stringa di input alla ricerca: fooHo trovato il testo foo partendo dall'indice 0 fino all'indice 3.

Questo confronto è stato un successo. Si noti che mentre la stringa di input è di 3 caratteri, l'indice iniziale è 0 e l'indice finale è 3. Per convenzione, gli intervalli includono l'indice iniziale ed escludono l'indice finale, come mostrato nella figura seguente:

La stringa foo letterale, con celle numerate e valori indice.

Ogni carattere della stringa risiede nella propria cella, con le posizioni indice puntato tra le celle. La stringa "foo" inizia in corrispondenza dell'indice 0 e termina nella posizione di indice 3, anche se gli stessi caratteri occupano solo le celle 0, 1 e 2. Con i confronti successivi, si noterà una certa sovrapposizione, l'indice di partenza per i successivi confronti è lo stesso dell'indice finale del confronto precedente: Enter your regex: fooEnter input string to search: foofoofooI found the text foo starting at index 0 and ending at index 3.I found the text foo starting at index 3 and ending at index 6.I found the text foo starting at index 6 and ending at index 9.

20

Regular Expression

metacaratteriQuesta API supporta inoltre una serie di caratteri speciali che influenzano il modo in cui è abbinato un modello. Modificare l'espressione regolare per cat. e la stringa di input per i cats. L'output apparirà come segue:

Enter your regex: cat.Enter input string to search: catsI found the text cats starting at index 0 and ending at index 4.

Il confronto riesce ancora, anche se il punto "." non è presente nella stringa di input. Succede perché il punto è un metacarattere - un carattere con un significato speciale interpretato dal matcher. Il metacarattere "." significa "qualsiasi carattere", che è il motivo per cui il confronto riesce in questo esempio.

I metacaratteri supportati da questo API sono: <?. ([{! \ ^ - $ = |]}) * +>

Nota: In alcune situazioni i caratteri speciali sopra elencati non saranno trattati come metacaratteri. Incontrerete ciò e come si impara a costruire espressioni regolari. È possibile, tuttavia, utilizzare questo elenco per verificare se un carattere specifico potrà mai essere considerato un metacarattere. Ad esempio, i caratteri ! @ # E non hanno un significato speciale.

• Ci sono due modi per forzare un metacarattere di essere trattato come un carattere normale: precedere il metacarattere con un backslash, o

• racchiuderlo all'interno di \Q (che inizia la citazione) e \E (che finisce).

Quando si utilizza questa tecnica, il \Q e \E può essere posizionato in qualsiasi posizione all'interno della espressione, a condizione che il \Q venga prima.

classi di caratteriSe si passa attraverso la specifica classe Pattern, vedrete tabelle di sintesi delle costrutti supportati espressioni regolari. Nelle sezione "classi di caratteri" troverete il seguente:

Construct Description[abc] a, b, or c (simple class)[^abc] Any character except a, b, or c (negation)[a-zA-Z] a through z, or A through Z, inclusive (range)[a-d[m-p]] a through d, or m through p: [a-dm-p] (union)[a-z&&[def]] d, e, or f (intersection)[a-z&&[^bc]] a through z, except for b and c: [ad-z] (subtraction)[a-z&&[^m-p]] a through z, and not m through p: [a-lq-z] (subtraction)

21

Regular Expression

La colonna di sinistra specifica i costrutti di espressioni regolari, mentre la colonna di destra descrive le condizioni in cui ogni costrutto si corrispondono. Nota: la parola "classe" o la frase "classe di caratteri" non si riferisce a una classe file. Nel contesto delle espressioni regolari, una classe di caratteri è un insieme di caratteri racchiusi tra parentesi quadre. Essa specifica i caratteri che corrispondono con successo un singolo carattere da una stringa di ingresso.

classi SempliciLa forma più elementare di una classe di caratteri è di mettere semplicemente un insieme di caratteri side-by-side tra parentesi quadre. Ad esempio, l'espressione regolare [bcr] corrisponderà alle parole "bat", "cat", o "topo", perché definisce una classe di caratteri (accettare o "b", "c", o "r") come il suo primo carattere.Enter your regex: [bcr]atEnter input string to search: batI found the text "bat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]atEnter input string to search: catI found the text "cat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]atEnter input string to search: ratI found the text "rat" starting at index 0 and ending at index 3.

Enter your regex: [bcr]atEnter input string to search: hatNo match found.

Negli esempi sopra riportati, la partita complessiva ha successo solo quando la prima lettera corrisponde uno dei caratteri definiti dalla classe di caratteri.

NegazionePer far corrispondere tutti i caratteri ad eccezione di quelli elencati, inserire il "^" metacarattere all'inizio della classe di caratteri. Questa tecnica è nota come negazione. Enter your regex: [^bcr]atEnter input string to search: batNo match found.

Enter your regex: [^bcr]atEnter input string to search: catNo match found.

Enter your regex: [^bcr]atEnter input string to search: ratNo match found.

Enter your regex: [^bcr]atEnter input string to search: hatI found the text "hat" starting at index 0 and ending at index 3.

22

Regular Expression

Il confronto ha successo solo se il primo carattere della stringa in input non contiene nessuno dei caratteri definiti dalla classe di caratteri.

CampiA volte si vuole definire una classe di caratteri che comprende una serie di valori, come ad esempio le lettere "A ad H" o i numeri "da 1 a 5". Per specificare un intervallo, è sufficiente inserire il "-" metacarattere tra il primo e l'ultimo carattere da abbinare, come ad esempio [1-5] o [a-h]. È inoltre possibile inserire diversi intervalli l'uno accanto all'altro all'interno della classe per espandere ulteriormente le possibilità delle partite. Ad esempio, [a-zA-Z] corrisponde ad ogni lettera dell'alfabeto: dalla A alla Z (minuscolo) o dalla A alla Z (maiuscolo). Ecco alcuni esempi di campi e negazioni:

Enter your regex: [a-c]Enter input string to search: aI found the text "a" starting at index 0 and ending at index 1.

Enter your regex: [a-c]Enter input string to search: bI found the text "b" starting at index 0 and ending at index 1.

Enter your regex: [a-c]Enter input string to search: cI found the text "c" starting at index 0 and ending at index 1.

Enter your regex: [a-c]Enter input string to search: dNo match found.

Enter your regex: foo[1-5]Enter input string to search: foo1I found the text "foo1" starting at index 0 and ending at index 4.

Enter your regex: foo[1-5]Enter input string to search: foo5I found the text "foo5" starting at index 0 and ending at index 4.

Enter your regex: foo[1-5]Enter input string to search: foo6No match found.

Enter your regex: foo[^1-5]Enter input string to search: foo1No match found.

Enter your regex: foo[^1-5]Enter input string to search: foo6I found the text "foo6" starting at index 0 and ending at index 4.

23

Regular Expression

UnioniÈ inoltre possibile utilizzare i raggruppamenti per creare una singola classe di caratteri composta da due o più classi di caratteri distinti. Per creare un raggruppamento, è sufficiente nidificare una classe dentro l'altra, come ad esempio [0-4 [6-8]]. Questa unione particolare crea una singola classe di caratteri che corrisponde ai numeri 0, 1, 2, 3, 4, 6, 7 e 8. Enter your regex: [0-4[6-8]]Enter input string to search: 0I found the text "0" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]Enter input string to search: 5No match found.

Enter your regex: [0-4[6-8]]Enter input string to search: 6I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]Enter input string to search: 8I found the text "8" starting at index 0 and ending at index 1.

Enter your regex: [0-4[6-8]]Enter input string to search: 9No match found.

IntersezioniPer creare una sola classe di caratteri corrispondente solo ai caratteri comuni a tutte le sue classi nidificate, si usa &&, come in [0-9 && [345]]. Questo particolare miscuglio consente di creare una classe a cui corrispondono solo i numeri comuni alle due classi di caratteri: 3, 4 e 5. Equivale all'intersezione fra insiemi.

Enter your regex: [0-9&&[345]]Enter input string to search: 3I found the text "3" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]Enter input string to search: 4I found the text "4" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]Enter input string to search: 5I found the text "5" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[345]]Enter input string to search: 2No match found.

Enter your regex: [0-9&&[345]]Enter input string to search: 6No match found.

24

Regular Expression

Ed ecco un esempio che mostra l'intersezione di due intervalli numerici:

Enter your regex: [2-8&&[4-6]]Enter input string to search: 3No match found.

Enter your regex: [2-8&&[4-6]]Enter input string to search: 4I found the text "4" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]Enter input string to search: 5I found the text "5" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]Enter input string to search: 6I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [2-8&&[4-6]]Enter input string to search: 7No match found.

SottrazioneInfine, è possibile utilizzare la sottrazione negando una o più classi di caratteri nidificati, ad esempio [0-9 && [^ 345]]. Questo esempio crea una singola classe di caratteri che corrisponde tutto da 0 a 9, ad eccezione dei numeri 3, 4 e 5.

Enter your regex: [0-9&&[^345]]Enter input string to search: 2I found the text "2" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[^345]]Enter input string to search: 3No match found.

Enter your regex: [0-9&&[^345]]Enter input string to search: 4No match found.

Enter your regex: [0-9&&[^345]]Enter input string to search: 5No match found.

Enter your regex: [0-9&&[^345]]Enter input string to search: 6I found the text "6" starting at index 0 and ending at index 1.

Enter your regex: [0-9&&[^345]]Enter input string to search: 9I found the text "9" starting at index 0 and ending at index 1.

Ora che abbiamo esaminato come sono create le classi di caratteri, si consiglia di rivedere la tabella dei caratteri Classi prima di continuare con la sezione successiva.

25

Regular Expression

Classi di caratteri predefinitiIl Pattern API contiene una serie di utili classi di caratteri predefiniti, che offrono convenienti abbreviazioni comunemente usati per le espressioni regolari:

Construct Description. Any character (may or may not match line terminators)\d A digit: [0-9]\D A non-digit: [^0-9]\s A whitespace character: [ \t\n\x0B\f\r]\S A non-whitespace character: [^\s]\w A word character: [a-zA-Z_0-9]\W A non-word character: [^\w]

Nella tabella di cui sopra, ciascun costrutto nella colonna di sinistra è un'abbreviazione per la classe di caratteri nella colonna di destra. Ad esempio, \d: una serie di cifre (0-9), e \w significa un carattere di parola (qualsiasi lettera minuscola, una lettera maiuscola, il carattere di sottolineatura, o tutte le cifre). E' bene utilizzare le classi predefinite quando possibile. Esse rendono il codice più facile da leggere ed eliminano gli errori introdotti da classi di caratteri non validi.

Costrutti che iniziano con un backslash sono chiamati costrutti escapizzati (escaped constructs). Abbiamo previsto costrutti ecsapizzati nella sezione stringhe di letterali dove abbiamo menzionato l'uso di backslash e \Q ed \E per la citazione. Se si utilizza un costrutto escape all'interno di una stringa letterale, è necessario precedere il backslash con un backslash per la stringa per la compilazione. Ad esempio:

private final String REGEX = "\\d"; // a single digit

In questo esempio \d è l'espressione regolare, il backslash extra è necessario per il codice da compilare (lo richiede Java). Il test harness legge le espressioni direttamente dalla console, comunque, in modo che il backslash extra non sia necessario. I seguenti esempi dimostrano l'uso di classi di caratteri predefiniti.

Enter your regex: .Enter input string to search: @I found the text "@" starting at index 0 and ending at index 1.

Enter your regex: . Enter input string to search: 1I found the text "1" starting at index 0 and ending at index 1.

Enter your regex: .Enter input string to search: a

26

Regular Expression

I found the text "a" starting at index 0 and ending at index 1.Enter your regex: \dEnter input string to search: 1I found the text "1" starting at index 0 and ending at index 1.

Enter your regex: \dEnter input string to search: aNo match found.

Enter your regex: \DEnter input string to search: 1No match found.

Enter your regex: \DEnter input string to search: aI found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \sEnter input string to search: I found the text " " starting at index 0 and ending at index 1.

Enter your regex: \sEnter input string to search: aNo match found.

Enter your regex: \SEnter input string to search: No match found.

Enter your regex: \SEnter input string to search: aI found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \wEnter input string to search: aI found the text "a" starting at index 0 and ending at index 1.

Enter your regex: \wEnter input string to search: !No match found.

Enter your regex: \WEnter input string to search: aNo match found.

Enter your regex: \WEnter input string to search: !I found the text "!" starting at index 0 and ending at index 1.

Nei primi tre esempi, l'espressione regolare è semplicemente . (il "dot" metacarattere) che indica "qualsiasi carattere". Pertanto, il confronto ha successo in tutti e tre i casi (un carattere selezionato casualmente @, una cifra, e una lettera). Gli esempi che seguono (ciascuno sono una singola espressione regolare) sono costruiti dalla tabella predefinita di classi di caratteri.

27

Regular Expression

È possibile fare riferimento a questa tabella per capire la logica dietro ad ogni confronto:

• \d corrisponde a tutte le cifre• \s corrisponde a spazi• \w corrisponde a caratteri di parola

In alternativa, una lettera maiuscola significa all'opposto:

• \D non corrisponde a cifre• \S non corrisponde a spazio • \W corrisponde caratteri non alfanumerici

quantificatoriQuantificatori consentono di specificare il numero di occorrenze da confrontare. Per comodità, le tre sezioni della specifica del modello API che descrive quantificatori greedy (avido), riluttante, e possessivo sono presentati qui di seguito. A prima vista può sembrare che i quantificatori X?, X?? e X?+ possano fare esattamente la stessa cosa, dal momento che tutti promettono di confrontare "X, una volta o per niente". Ci sono sottili differenze di implementazione che saranno spiegate verso la fine di questa sezione.

Greedy Reluctant Possessive MeaningX? X?? X?+ X, once or not at allX* X*? X*+ X, zero or more timesX+ X+? X++ X, one or more timesX{n} X{n}? X{n}+ X, exactly n timesX{n,} X{n,}? X{n,}+ X, at least n timesX{n,m} X{n,m}? X{n,m}+ X, at least n but not more than m times

Volgiamo il nostro sguardo al quantificatori greedy con la creazione di tre diverse espressioni regolari: la lettera "A" seguita da uno, * o +?. Vediamo cosa succede quando queste espressioni vengono testati contro una stringa di input vuota "": Enter your regex: a?Enter input string to search: I found the text "" starting at index 0 and ending at index 0.

Enter your regex: a*Enter input string to search: I found the text "" starting at index 0 and ending at index 0.

Enter your regex: a+Enter input string to search: No match found.

28

Regular Expression

Confronti a Lunghezza-ZeroNell'esempio precedente, il confronto ha successo nei primi due casi perché le espressioni di un ? e un * entrambe consentono zero occorrenze della lettera a. Noterete anche che gli indici di inizio e fine sono entrambi pari a zero, il che è diverso da qualsiasi degli esempi che abbiamo visto finora. La stringa di input vuota "" non ha lunghezza, quindi il test corrisponde semplicemente niente di indice 0. Confronti di questo tipo sono noti come confronti di lunghezza zero. Una corrispondenza di lunghezza zero può avvenire in diversi casi: in una stringa di input vuota, all'inizio di una stringa di input, dopo l'ultimo carattere di una stringa di input, o tra due caratteri di una stringa di input. Confronti di lunghezza zero sono facilmente identificabili perché inizia e finisce sempre nella posizione di indice stesso. Analizziamo i confronti di lunghezza zero, con alcuni altri esempi. Modificare la stringa di input a una singola lettera "a" e noterete qualcosa di interessante :: Enter your regex: a?Enter input string to search: aI found the text "a" starting at index 0 and ending at index 1.I found the text "" starting at index 1 and ending at index 1.

Enter your regex: a*Enter input string to search: aI found the text "a" starting at index 0 and ending at index 1.I found the text "" starting at index 1 and ending at index 1.

Enter your regex: a+Enter input string to search: aI found the text "a" starting at index 0 and ending at index 1.

Tutti e tre i quantificatori trovano la lettera "a", ma i primi due anche trovato una corrispondenza di lunghezza zero in corrispondenza dell'indice 1, vale a dire dopo l'ultimo carattere della stringa di input. Ricordate, l'identificatore vede il carattere "a", come seduto in cella tra indice 0 e indice 1, e il nostro ciclo del test harness fino a quando non è più possibile trovare una corrispondenza. A seconda del quantificatore utilizzato, la presenza di "nulla" in corrispondenza dell'indice dopo l'ultimo carattere può o non può attivare un confronto. Ora cambiate la stringa di input alla lettera "a" cinque volte di fila e si otterrà il seguente: Enter your regex: a?Enter input string to search: aaaaaI found the text "a" starting at index 0 and ending at index 1.I found the text "a" starting at index 1 and ending at index 2.I found the text "a" starting at index 2 and ending at index 3.I found the text "a" starting at index 3 and ending at index 4.I found the text "a" starting at index 4 and ending at index 5.I found the text "" starting at index 5 and ending at index 5.Enter your regex: a*Enter input string to search: aaaaaI found the text "aaaaa" starting at index 0 and ending at index 5.I found the text "" starting at index 5 and ending at index 5.Enter your regex: a+Enter input string to search: aaaaaI found the text "aaaaa" starting at index 0 and ending at index 5.

29

Regular Expression

L'espressione a? trova una corrispondenza individuale per ogni carattere, dal momento che la corrispondenza ha successo quando "a" appare zero o una volta. L'espressione a* trova due lotti distinti: tutti della lettera "a" 's nel primo lotto, poi la corrispondenza di lunghezza zero dopo l'ultimo carattere all'indice 5. E infine, a+ corrisponde a tutte le occorrenze della lettera "a", ignorando la presenza di "nulla" all'ultimo indice. A questo punto, forse vi starete chiedendo quali sarebbero i risultati se i primi due quantificatori incontrano una lettera diversa da "a". Ad esempio, cosa succede se incontra la lettera "b", come in "ababaaaab"? Andiamo a scoprirlo: Enter your regex: a?Enter input string to search: ababaaaabI found the text "a" starting at index 0 and ending at index 1.I found the text "" starting at index 1 and ending at index 1.I found the text "a" starting at index 2 and ending at index 3.I found the text "" starting at index 3 and ending at index 3.I found the text "a" starting at index 4 and ending at index 5.I found the text "a" starting at index 5 and ending at index 6.I found the text "a" starting at index 6 and ending at index 7.I found the text "a" starting at index 7 and ending at index 8.I found the text "" starting at index 8 and ending at index 8.I found the text "" starting at index 9 and ending at index 9.

Enter your regex: a*Enter input string to search: ababaaaabI found the text "a" starting at index 0 and ending at index 1.I found the text "" starting at index 1 and ending at index 1.I found the text "a" starting at index 2 and ending at index 3.I found the text "" starting at index 3 and ending at index 3.I found the text "aaaa" starting at index 4 and ending at index 8.I found the text "" starting at index 8 and ending at index 8.I found the text "" starting at index 9 and ending at index 9.

Enter your regex: a+Enter input string to search: ababaaaabI found the text "a" starting at index 0 and ending at index 1.I found the text "a" starting at index 2 and ending at index 3.I found the text "aaaa" starting at index 4 and ending at index 8.

Anche se la lettera "b" appare in celle 1, 3 e 8, l'uscita riporta una corrispondenza di lunghezza zero in quei punti. L'espressione regolare ? non è specificamente alla ricerca per la lettera "b", ma sta solo cercando la presenza (o mancanza) della lettera "a". Se il quantificatore consente un confronto di "a" zero volte, tutto nella stringa di input che non è una "a" apparirà come una corrispondenza di lunghezza zero. Al rimanente sono abbinate secondo le regole discusse negli esempi precedenti.

30

Regular Expression

Per confrontare una sequenza esattamente n volte, è sufficiente specificare il numero di una serie all'interno di parentesi graffe:Enter your regex: a{3}Enter input string to search: aaNo match found.Enter your regex: a{3}Enter input string to search: aaaI found the text "aaa" starting at index 0 and ending at index 3.Enter your regex: a{3}Enter input string to search: aaaaI found the text "aaa" starting at index 0 and ending at index 3.

Qui, l'espressione regolare a {3} è alla ricerca di tre occorrenze della lettera "a" in una riga. Il primo test ha esito negativo perché la stringa di input non è sufficiente uno è da confrontare. La seconda prova contiene esattamente 3 bis nella stringa di input, che innesca una corrispondenza. Il terzo test innesca anche una corrispondenza perché ci sono esattamente 3 a, all'inizio della stringa di input. Tutto ciò segue che è irrilevante per il primo lotto. Se la ricorrenza dovesse riapparire dopo quel punto, dovrebbe innescare i confronti successivi: Enter your regex: a{3}Enter input string to search: aaaaaaaaaI found the text "aaa" starting at index 0 and ending at index 3.I found the text "aaa" starting at index 3 and ending at index 6.I found the text "aaa" starting at index 6 and ending at index 9.

Per richiedere un modello a comparire almeno n volte, aggiungere una virgola dopo il numero:Enter your regex: a{3,}Enter input string to search: aaaaaaaaaI found the text "aaaaaaaaa" starting at index 0 and ending at index 9.

Con la stessa stringa di input, questo test trova un solo confronto, perché le 9 a in una riga soddisfa la necessità di "almeno" 3 a. Infine, per specificare un limite superiore al numero di occorrenze, aggiungere un secondo numero all'interno delle parentesi graffe:Enter your regex: a{3,6} // find at least 3 (but no more than 6) a's in a rowEnter input string to search: aaaaaaaaaI found the text "aaaaaa" starting at index 0 and ending at index 6.I found the text "aaa" starting at index 6 and ending at index 9.

Qui il primo confronto è costretto a fermarsi al limite superiore di 6 caratteri. Il secondo confronto include tutto ciò che è rimasto, che sembra essere uno di tre - il numero minimo di caratteri consentiti per questo confronto. Se la stringa di input fosse stata un carattere in meno, non ci sarebbe stato un secondo confronto dato che solo due a sarebbero rimasti.

31

Regular Expression

Catturare gruppi e le classi di caratteri con QuantificatoriFino ad ora, abbiamo solo testato quantificatori sulle stringhe di input che contengono un carattere. In realtà, i quantificatori possono allegare solo per un carattere alla volta, quindi l'espressione regolare "abc +" significa "a, seguito da b, c seguita da una o più volte". Non significherebbe "abc" una o più volte. Tuttavia, quantificatori possono anche attaccare classi di caratteri e gruppi di cattura, come ad esempio [abc] + (a o b o c, una o più volte) o (abc) + (il gruppo "abc", una o più volte). Illustriamo specificando il gruppo (dog), tre volte di fila.

Enter your regex: (dog){3}Enter input string to search: dogdogdogdogdogdogI found the text "dogdogdog" starting at index 0 and ending at index 9.I found the text "dogdogdog" starting at index 9 and ending at index 18.

Enter your regex: dog{3}Enter input string to search: dogdogdogdogdogdogNo match found.

Ecco il primo esempio trova tre confronti, dato che il quantificatore si applica a tutto il gruppo di cattura. Rimosse le parentesi, tuttavia, il confronto non riesce perché il quantificatore {3} si applica ora solo alla lettera "g". Allo stesso modo, possiamo applicare un quantificatore a un intera classe di caratteri:

Enter your regex: [abc]{3}Enter input string to search: abccabaaaccbbbcI found the text "abc" starting at index 0 and ending at index 3.I found the text "cab" starting at index 3 and ending at index 6.I found the text "aaa" starting at index 6 and ending at index 9.I found the text "ccb" starting at index 9 and ending at index 12.I found the text "bbc" starting at index 12 and ending at index 15.

Enter your regex: abc{3}Enter input string to search: abccabaaaccbbbcNo match found.

Qui il quantificatore {3} si applica alla intera classe di caratteri nel primo esempio, ma solo alla lettera "c" nel secondo.

Differenze Tra quantificatori avido, riluttante, e possessivo. Ci sono sottili differenze tra quantificatori greedy (avido), riluttante, e possessivo. Quantificatori greedy sono considerati "greedy" (avidi), perché costringono l'identificatore di leggere, o mangiare, l'intera stringa di input prima di tentare il primo confronto. Se il tentativo di prima corrispondenza (l'intera stringa di input) non riesce, l'identificatore sfila la stringa di input di un carattere e cerca di nuovo, ripetendo il processo fino a quando viene trovata una corrispondenza o non ci sono più caratteri lasciati da fare marcia indietro.

32

Regular Expression

A seconda del quantificatore utilizzato nell'espressione, l'ultima cosa proverà corrispondenza con 1 o 0 caratteri. I quantificatori riluttanti, tuttavia, prendono l'approccio opposto: partono all'inizio della stringa di input, quindi a malincuore prelevano un carattere alla volta per trovare una corrispondenza. L'ultima cosa che si cerca è la stringa di intero input. Infine, i quantificatori possessivi prendono sempre l'intera stringa di input, cercando una volta (e solo una volta) per il confronto. A differenza dei quantificatori greedy, i quantificatori possessivi non tornano mai indietro, anche se ciò favorirebbe il confronto. Per illustrare, consideriamo il xfooxxxxxxfoo come stringa di input.

Enter your regex: .*foo // greedy quantifierEnter input string to search: xfooxxxxxxfooI found the text "xfooxxxxxxfoo" starting at index 0 and ending at index 13.

Enter your regex: .*?foo // reluctant quantifierEnter input string to search: xfooxxxxxxfooI found the text "xfoo" starting at index 0 and ending at index 4.I found the text "xxxxxxfoo" starting at index 4 and ending at index 13.

Enter your regex: .*+foo // possessive quantifierEnter input string to search: xfooxxxxxxfooNo match found.

Il primo esempio utilizza il quantificatore greedy .* Per trovare "nulla", zero o più volte, seguita dalle lettere "f" "o" "o". Poiché il quantificatore è avido, l' .* parte dell'espressione mangia per primo l'intera stringa di input. A questo punto, l'espressione generale non può avere successo, poiché le ultime tre lettere "f" "o" "o") sono già stati consumati. Così il matcher appoggia lentamente fuori una lettera alla volta sino al verificarsi più a destra di "foo" è stato rigurgitato, a questo punto il confronto ha esito positivo e la ricerca termina.

Il secondo esempio, invece, è riluttante, in modo che inizia dalla prima consumando "niente". Perché "foo" non compare all'inizio della stringa, è costretto ad ingoiare la prima lettera (una "x"), che innesca il primo confronto a 0 e 4. Il nostro test harness continua il processo fino a quando la stringa di input è esaurita. Essa trova un altro match a 4 e 13.

Il terzo esempio non riesce a trovare una corrispondenza perché il quantificatore è possessivo. In questo caso, la stringa intera di input viene consumata da .*+, lasciando zero residui in grado di soddisfare la "foo" alla fine dell'espressione. Utilizzare un quantificatore possessivo per le situazioni in cui si desidera cogliere tutte di qualcosa, senza mai indietreggiare, ma sorpasserà il quantificatore equivalente greedy nei casi in cui il confronto non è immediatamente trovato.

33

Regular Expression

Gruppi di catturaNel paragrafo precedente abbiamo visto come allegare un carattere quantificatore, classe di caratteri, o gruppo di cattura in un qualsiasi momento. Ma fino ad ora, non abbiamo discusso il concetto di gruppi di cattura in dettaglio. Gruppi di cattura sono un modo di trattare più caratteri come una singola unità. Essi sono creati inserendo i caratteri che devono essere raggruppati all'interno di una serie di parentesi. Ad esempio, l'espressione regolare (dog) crea un singolo gruppo contenente le lettere "d" "o" e "g". La porzione della stringa di input che corrisponde al gruppo di cattura verranno salvati nella memoria per successivo richiamo via backreferences (come discusso in seguito, nella sezione backreference).

NumerazioneCome descritto nella Pattern API, gruppi di cattura sono numerati contando le parentesi che si aprono da sinistra a destra. Nell'espressione ((A) (B (C))), per esempio, ci sono quattro tali gruppi:

((A) (B (C))) (A) (B (C)) (C)

Per scoprire quanti gruppi sono presenti nella espressione, chiamare il metodo groupCount su un oggetto matcher. Il metodo restituisce un int groupCount mostra il numero di gruppi di cattura presenti nel modello dell'identificatore. In questo esempio, groupCount restituisce il numero 4, che mostra che il modello contiene 4 gruppi di cattura. Vi è anche un gruppo speciale, gruppo 0, che rappresenta sempre l'intera espressione. Questo gruppo non è incluso nel totale riportato da groupCount. Gruppi che iniziano con (? Sono puri, non cattura i gruppi che non catturano il testo e non contano ai fini del totale di gruppo. (Vedrete esempi di non catturare i gruppi più avanti in Metodi parte della classe Pattern.) E 'importante capire come i gruppi sono contati perché alcuni metodi Matcher accettano un int specificando un determinato numero di gruppo come parametro:

• pubblic start int (gruppo int): Restituisce l'indice inizio del sottosequenza catturato dal gruppo dato durante l'operazione del precedente confronto.

• pubblic end int (gruppo int): Restituisce l'indice dell'ultimo carattere, più uno, della sottosequenza catturato dal gruppo dato durante l'operazione del confronto precedente.

• gruppo di public String (gruppo int): Restituisce la sottosequenza di ingresso catturato dal gruppo dato durante l'operazione del confronto precedente.

34

Regular Expression

BackreferencesLa sezione della stringa di input corrispondente al gruppo di cattura (s) viene salvato nella memoria per successivo richiamo attraverso backreference. A backreference è specificato nella espressione regolare come un backslash (\) seguita da una cifra che indica il numero del gruppo da ricordare. Ad esempio, l'espressione (\d\d) definisce un gruppo di acquisizione corrispondente due cifre in una fila, che possono essere richiamati successivamente nell'espressione attraverso il backreference \1. Per abbinare le 2 cifre, seguite dalle stesse identiche due cifre, si può usare (\d\d)\1 come l'espressione regolare:Enter your regex: (\d\d)\1Enter input string to search: 1212I found the text "1212" starting at index 0 and ending at index 4.

Se si modificano le ultime due cifre della partita fallirà: Enter your regex: (\d\d)\1Enter input string to search: 1234No match found.

Per annidati gruppi di cattura, riferimento all'indietro funziona esattamente nello stesso modo: Specificare un backslash seguito dal numero del gruppo da richiamare.

Adattatori Boundary (di confine)Fino ad ora, abbiamo solo stati interessati a sapere se o non viene trovata una corrispondenza in qualche luogo all'interno di una stringa particolare di input. Non abbiamo mai curato su dove nella stringa il confronto si stava svolgendo. Potete fare il vostro pattern corrispondente più preciso, specificando tali informazioni con adattatori di contorno. Per esempio, forse siete interessati a trovare una determinata parola, ma solo se appare all'inizio o alla fine di una riga. O forse volete sapere se il confronto si svolge su un confine di parola, o alla fine del confronto precedente. La seguente tabella elenca e spiega tutti gli adattatori del contorno.

Boundary Construct Description^ The beginning of a line$ The end of a line\b A word boundary\B A non-word boundary\A The beginning of the input\G The end of the previous match\Z The end of the input but for the final terminator, if any\z The end of the input

35

Regular Expression

I seguenti esempi dimostrano l'uso di adattatori di confine ^ e $. Come notato sopra, ^ corrisponde l'inizio di una linea, e $ corrisponde alla fine. Enter your regex: ^dog$Enter input string to search: dogI found the text "dog" starting at index 0 and ending at index 3.

Enter your regex: ^dog$Enter input string to search: dogNo match found.

Enter your regex: \s*dog$Enter input string to search: dogI found the text " dog" starting at index 0 and ending at index 15.

Enter your regex: ^dog\w*Enter input string to search: dogblahblahI found the text "dogblahblah" starting at index 0 and ending at index 11.

Il primo esempio ha successo perché il modello occupa l'intera stringa di input. Il secondo esempio non riesce perché la stringa di ingresso contiene lo spazio vuoto all'inizio. Il terzo esempio specifica un'espressione che consente illimitati spazi bianchi, seguiti da "dog" alla fine della linea. Il quarto esempio è necessario che "dog" sia presente all'inizio di una linea seguita da un numero illimitato di caratteri alfanumerici. Per verificare se un modello inizia e finisce su un confine di parola (al contrario di una sottostringa all'interno di una stringa più lunga), basta usare \b su entrambi i lati, ad esempio, \bdog\b Enter your regex: \bdog\bEnter input string to search: The dog plays in the yard.I found the text "dog" starting at index 4 and ending at index 7.

Enter your regex: \bdog\bEnter input string to search: The doggie plays in the yard.No match found.

Per abbinare l'espressione in modo non-confine di parola, utilizzare \ B invece: Enter your regex: \bdog\BEnter input string to search: The dog plays in the yard.No match found.

Enter your regex: \bdog\BEnter input string to search: The doggie plays in the yard.I found the text "dog" starting at index 4 and ending at index 7.

Per richiedere che il confronto si verifichi solo alla fine del lotto precedente, utilizzare \G: Enter your regex: dog Enter input string to search: dog dogI found the text "dog" starting at index 0 and ending at index 3.I found the text "dog" starting at index 4 and ending at index 7.

Enter your regex: \Gdog Enter input string to search: dog dogI found the text "dog" starting at index 0 and ending at index 3.

36

Regular Expression

Ecco il secondo esempio si trova una solo confronto, perché il secondo "dog "non si avvia alla fine del confronto precedente.

Metodi della classe PatternFino ad ora, abbiamo solo usato il test harness (sfruttare) per creare oggetti di pattern nella loro forma più elementare. Questa sezione esplora tecniche avanzate come la creazione di modelli con i flag e l'utilizzo di espressioni flag inclusi. Si esplorano anche alcuni altri metodi utili che non abbiamo ancora discusso.

Creazione di un modello con flags• La classe modello definisce un metodo alternativo di compilazione che accetta

un insieme di flag che influenzano il modo in cui è abbinato il modello. Il parametro flags è una maschera di bit che può includere uno dei seguenti campi statici pubblici: Pattern.CANON_EQ Abilita equivalenza canonica. Quando questo flag viene specificato, due caratteri saranno presi in considerazione per soddisfare se, e solo se, le loro scomposizioni canoniche complete corrispondono. L'espressione "a \u030A", per esempio, corrispondono alla stringa "\u00E5" quando questo flag è specificato. Per impostazione predefinita, la corrispondenza non prende in considerazione l'equivalenza canonica. Specificando questo flag può imporre una riduzione delle prestazioni.

• Pattern.CASE_INSENSITIVE Abilita case-insensitive matching. Per impostazione predefinita, la corrispondenza case-insensitive presuppone che solo i caratteri del set di caratteri US-ASCII vengono abbinati. LA corrispondenza Unicode-aware case-insensitive può essere attivata specificando il flag UNICODE_CASE in concomitanza con questo flag. La corrispondenza Case-insensitive può essere attivato anche tramite l'espressione flag incorporato (?I). Specificando questo flag può imporre una penalità in termini di prestazioni.

• Pattern.COMMENTS permessi spazi bianchi e commenti nel pattern. In questo modo, lo spazio viene ignorato, ed inclusi i commenti che iniziano con # vengono ignorati fino alla fine di una riga. Modalità dei commenti può essere attivato anche tramite l'espressione flag incorporata (?X).

• Pattern.COMMENTS permessi spazi bianchi e commenti nel pattern.• Pattern.DOTALL Attiva la modalità dotall. In modalità dotall, l'espressione.

corrisponde a qualsiasi carattere, compreso un terminatore di linea. Per impostazione predefinita questa espressione non corrisponde ai terminatori di linea. Modalità dotall può essere attivato anche tramite l'espressione flag incorporato (?S). (La s è un mnemonico per la modalità "single-line", che è quello che si chiama in Perl).

37

Regular Expression

• Pattern.LITERAL Consente l'analisi letterale del pattern. Quando questo flag è specificato quindi la stringa di input che specifica il motivo è trattata come una sequenza di caratteri letterali. Metacaratteri o sequenze di escape nella sequenza di input non sarà dato alcun significato particolare. Il flag CASE_INSENSITIVE e il flag UNICODE_CASE conservano il loro impatto sulla corrispondenza se usato in combinazione con questo flag. Gli altri flag diventano superflui. Non vi è alcun carattere flag incorporato per consentire l'analisi letterale.

• Pattern.MULTILINE Attiva modalità multi. In modalità multi le espressioni ^ e $ corrispondono appena dopo o poco prima, rispettivamente, un terminatore di linea o la fine della sequenza di input. Per default queste espressioni hanno corrispondenza solo all'inizio e alla fine della sequenza di intero input. La modalità multi può essere attivato anche tramite l'espressione bandiera incorporato (?M).

• Pattern.UNICODE_CASE Abilita Unicode-aware pieghevole caso. Quando questo flag viene specificato, case-insensitive matching, se abilitata dal flag CASE_INSENSITIVE, è fatto in modo coerente con lo standard Unicode. Per impostazione predefinita, la corrispondenza case-insensitive presuppone che solo i caratteri del set di caratteri US-ASCII vengono abbinati. Il caso Unicode-aware folding può essere attivato anche tramite l'espressione flag incorporato (?U). Specificando questo flag può imporre una riduzione delle prestazioni.

• Pattern.UNIX_LINES Abilita Unix modalità linee. In questo modo, solo il '\ n' terminatore di linea è riconosciuto nel comportamento dei ., ^ e $. Unix modalità linee può essere attivato anche tramite l'espressione flag incorporato (?D).

Nei passi seguenti si modificherà il test harness, RegexTestHarness.java per creare un modello con case-insensitive matching. In primo luogo, modificare il codice per chiamare la versione alternativa di compilazione:

Pattern pattern = Pattern.compile(console.readLine("%nEnter your regex: "),Pattern.CASE_INSENSITIVE);

Quindi compilare ed eseguire il test harness per ottenere i seguenti risultati: Enter your regex: dogEnter input string to search: DoGDOgI found the text "DoG" starting at index 0 and ending at index 3.I found the text "DOg" starting at index 3 and ending at index 6.

Come potete vedere, il valore letterale stringa "dog" corrisponde a entrambe le occorrenze, indipendentemente dal caso.

38

Regular Expression

Per compilare un modello con le bandiere, separare le bandiere da inserire utilizzando l'operatore OR bit per bit "|". Per chiarezza, gli esempi di codice seguenti hardcode l'espressione regolare, invece di leggere dal Console:

pattern = Pattern.compile("[az]$", Pattern.MULTILINE | Pattern.UNIX_LINES);

Si potrebbe anche specificare una variabile int, invece:final int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;Pattern pattern = Pattern.compile("aa", flags);

Espressioni Flag incorporateE 'anche possibile attivare varie bandiere utilizzando espressioni bandiera embedded. Espressioni bandiera incorporati sono un'alternativa alla versione a due argomenti di compilazione, e sono specificati nelle espressioni regolari stesso. L'esempio seguente utilizza il test originale (con la modifica di pagina precedente), RegexTestHarness.java con l'espressione flag incorporata (?I) per consentire case-insensitive matching.

Enter your regex: (?i)fooEnter input string to search: FOOfooFoOfoOI found the text "FOO" starting at index 0 and ending at index 3.I found the text "foo" starting at index 3 and ending at index 6.I found the text "FoO" starting at index 6 and ending at index 9.I found the text "foO" starting at index 9 and ending at index 12.

Ancora una volta, tutti i confronti riescono a prescindere dal caso.

Le espressioni flag incorporate che corrispondono ai campi pattern pubblicamente accessibili sono presentati nella seguente tabella:

Constant Equivalent Embedded Flag ExpressionPattern.CANON_EQ NonePattern.CASE_INSENSITIVE (?i)Pattern.COMMENTS (?x)Pattern.MULTILINE (?m)Pattern.DOTALL (?s)Pattern.LITERAL NonePattern.UNICODE_CASE (?u)Pattern.UNIX_LINES (?d)

39

Regular Expression

Utilizzo del metodo matches(String, CharSequence)La classe Pattern definisce un metodo conveniente matches per i confronti che permette di controllare rapidamente se un pattern è presente in una stringa di dati in input. Come con tutti i metodi pubblici statici, si dovrebbero richiamare i confronti dal loro nome di classe, come ad esempio Pattern.matches ("\\d", "1");. In questo esempio, il metodo restituisce true, in quanto la cifra "1" corrisponde l'espressione regolare \d.

Utilizzo del metodo split(String).Il metodo split è un grande strumento per raccogliere il testo che giace su entrambi i lati del modello che è stato trovato. Come mostrato nel programma in SplitDemo.java, il metodo split estrae le parole "uno due tre quattro cinque" dalla stringa "uno: due: tre: quattro: cinque":import java.util.regex.Pattern;import java.util.regex.Matcher;public class SplitDemo { private static final String REGEX = ":"; private static final String INPUT = "one:two:three:four:five"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); String[] items = p.split(INPUT); for(String s : items) { System.out.println(s); } }}OUTPUT:onetwothreefourfive

40

Regular Expression

Per semplicità, abbiamo abbinato una stringa letterale, i due punti (:) al posto di un'espressione complessa regolare. Dal momento che stiamo ancora usando gli oggetti Pattern e Matcher, è possibile utilizzare split per ottenere il testo che cade su entrambi i lati di ogni espressione regolare. Ecco lo stesso esempio, SplitDemo2.java, modificato in modo da dividere su cifre invece che con “:”. (il separatore in questo caso è formato da cifre e non da :)

import java.util.regex.Pattern;import java.util.regex.Matcher;public class SplitDemo2 { private static final String REGEX = "\\d"; private static final String INPUT = "one9two4three7four1five"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); String[] items = p.split(INPUT); for(String s : items) { System.out.println(s); } }}OUTPUT:onetwothreefourfive

41

Regular Expression

Altri metodi di utilitàSi possono trovare i seguenti metodi per essere di qualche utilità anche:

• pubblica static String quote(String s) restituisce una pattern letterale String per la stringa specificata. Questo metodo produce una stringa che può essere utilizzata per creare un Pattern che confronterebbe String s come se fosse un Pattern letterale. A metacaratteri o sequenze di escape nella sequenza di input non sarà dato alcun significato particolare.

• public String toString() Restituisce la rappresentazione String di questo Pattern. Questa è l'espressione regolare da cui è stato compilato questo Pattern.

Metodi equivalenti a pattern di java.lang.StringSupporto alle espressioni regolari esiste anche in java.lang.String attraverso metodi diversi che imitano il comportamento di java.util.regex.Pattern. Per comodità, estratti dalla loro chiave API sono presentati qui di seguito.

• public boolean matches(String regex): Indica se questa stringa corrisponde alla data espressione regolare. L'invocazione di questo metodo dalla forma str.matches(regex) si ottiene esattamente lo stesso risultato dell'espressione Pattern.matches(regex, str).

• public String[] Split(String regex, int limit): Divide la stringa in relazione agli incontri della data espressione regolare. L'invocazione di questo metodo di forma str.split(regex, n) si ottiene lo stesso risultato dell'espressione Pattern.compile (regex). Split (str, n)

• public String[] Split(String regex): Divide la stringa in relazione ai confronti della data espressione regolare. Questo metodo funziona allo stesso modo come se si invocavano i due argomenti del metodo split con l'espressione data e un argomento limite di zero. Infine stringhe vuote non sono incluse nella matrice risultante.

Vi è anche un metodo di sostituzione, che sostituisce un CharSequence con un altro:

• public String replace(target CharSequence, replacement CharSequence): Sostituisce ogni sottostringa di questa stringa che corrisponde alla sequenza letterale bersaglio con la sostituzione della specificata sequenza letterale. I proventi sostitutivi a partire dall'inizio della stringa fino alla fine, ad esempio, sostituendo "AA" con "b" nella stringa "aaa" si tradurrà in "ba" piuttosto che "ab".

42

Regular Expression

Metodi della classe MatcherQuesta sezione descrive alcuni metodi addizionali utili della classe Matcher. Per comodità, i metodi elencati di seguito sono raggruppati in base alla funzionalità.

Metodi IndiceIndice metodi forniscono valori di indice utili che mostrano con precisione dove la partita è stata trovata nella stringa di input:

• public int start(): Restituisce l'indice dell'inizio della partita precedente.• public int start(int group): Restituisce l'indice inizio del sottosequenza

catturato dal gruppo dato durante l'operazione del precedente confronto.• public int end(): restituisce l'offset dopo l'ultimo carattere corrispondente.• public int end(int group): restituisce l'offset dopo l'ultimo carattere del

sottosequenza catturato dal gruppo dato durante l'operazione partita precedente.

Metodi di studioMetodi di studio rivedere la stringa di input e restituisce un booleano che indica se il modello è stato trovato.

• public boolean lookingAt(): tentativi di corrispondono alla sequenza di ingresso, a partire dall'inizio della regione, contro il pattern.

• public boolean find(): I tentativi di trovare la sottosequenza successiva della sequenza di input che corrisponde al modello.

• public boolean find(int inizio): Ripristina questa Matcher e poi tenta di trovare la sottosequenza successiva della sequenza di input che corrisponde al modello, a partire dall'indice specificato.

• public boolean matches(): cerca la corrispondenza tutta la regione contro il pattern.

43

Regular Expression

Metodi di ricambioMetodi sostitutivi sono metodi utili per la sostituzione del testo in una stringa di input.

• public Matcher appendReplacement(StringBuffer sb, String replacement): Implementa un non-terminale aggiunge e sostituisce ad ogni passo.

• public StringBuffer appendTail(StringBuffer sb): implementazione di un terminale aggiunge e sostituisce ad ogni passo.

• replaceAll String public(sostituzione String): Sostituisce ogni sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.

• public String replaceFirst(String replacement): Sostituisce la prima sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione dato.

• public quoteReplacement static String(String s): restituisce una stringa letterale sostituzione per la stringa specificata. Questo metodo produce una String che funzionerà come un s sostituzione letterale nel metodo appendReplacement della classe Matcher. La stringa prodotta corrisponderà la sequenza di caratteri in s trattati come una sequenza letterale. Backslash ('\') e segni di dollaro ('$') non sarà dato alcun significato particolare.

Uso dei metodi di inizio e fineEcco un esempio, MatcherDemo.java, che conta il numero di volte che la parola "dog" compare nella stringa di input.

import java.util.regex.Pattern;import java.util.regex.Matcher;public class MatcherDemo { private static final String REGEX = "\\bdog\\b"; private static final String INPUT = "dog dog dog doggie dogg"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); // get a matcher object Matcher m = p.matcher(INPUT); int count = 0; while(m.find()) { count++; System.out.println("Match number "+ count); System.out.println("start(): "+ m.start()); System.out.println("end(): "+ m.end()); } }}

OUTPUT:

44

Regular Expression

Match number 1start(): 0end(): 3Match number 2start(): 4end(): 7Match number 3start(): 8end(): 11

Si può vedere che questo esempio viene utilizzato confini di parola per garantire che le lettere "d" "o" "g" non sono solo una sottostringa in una parola più lunga.

Esso fornisce anche alcune informazioni utili su dove nella stringa di input la partita si è verificato. Il metodo start restituisce l'indice inizio del sottosequenza catturato dal gruppo dato durante l'operazione di corrispondenza precedente, e alla fine restituisce l'indice dell'ultimo carattere corrisponde, più uno.

Uso dei metodi matches e lookingAtI metodi lookingAt e matches sia il tentativo di abbinare una sequenza di input nei confronti di un pattern. La differenza, tuttavia, è che il matches richiede l'intera sequenza di input da abbinare, mentre lookingAt no. Entrambi i metodi iniziano sempre all'inizio della stringa di input. Ecco il codice completo,

MatchesLooking.java: import java.util.regex.Pattern;import java.util.regex.Matcher;

public class MatchesLooking {

private static final String REGEX = "foo"; private static final String INPUT = "fooooooooooooooooo"; private static Pattern pattern; private static Matcher matcher;

public static void main(String[] args) { // Initialize pattern = Pattern.compile(REGEX); matcher = pattern.matcher(INPUT); System.out.println("Current REGEX is: " + REGEX); System.out.println("Current INPUT is: " + INPUT); System.out.println("lookingAt(): " + matcher.lookingAt()); System.out.println("matches(): " + matcher.matches()); }}Current REGEX is: fooCurrent INPUT is: fooooooooooooooooolookingAt(): truematches(): false

45

Regular Expression

Utilizzo di replaceFirst(String) e replaceAll(String)I metodi replaceFirst e replaceAll sostituiscono il testo che corrisponde a una data espressione regolare. Come indica il loro nome, replaceFirst sostituisce la prima occorrenza, e replaceAll sostituisce tutte le occorrenze. Ecco il codice ReplaceDemo.java:import java.util.regex.Pattern; import java.util.regex.Matcher;public class ReplaceDemo { private static String REGEX = "dog"; private static String INPUT = "The dog says meow. All dogs say meow."; private static String REPLACE = "cat"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); // get a matcher object Matcher m = p.matcher(INPUT); INPUT = m.replaceAll(REPLACE); System.out.println(INPUT); }}OUTPUT: The cat says meow. All cats say meow.

In questa prima versione, tutte le occorrenze di cane sono sostituiti con cat. Ma perché fermarsi qui? Piuttosto che sostituire un letterale semplice come il cane, è possibile sostituire testo che corrisponde a qualsiasi espressione regolare. L'API per questo metodo afferma che "data l'espressione regolare a * b, il aabfooaabfooabfoob input, e la stringa di sostituzione -. L'invocazione di questo metodo su un adattatore per l'espressione che darebbe la stringa “-foo-foo-foo-.”. Ecco il codice ReplaceDemo2.java:import java.util.regex.Pattern;import java.util.regex.Matcher; public class ReplaceDemo2 { private static String REGEX = "a*b"; private static String INPUT = "aabfooaabfooabfoob"; private static String REPLACE = "-"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); // get a matcher object Matcher m = p.matcher(INPUT); INPUT = m.replaceAll(REPLACE); System.out.println(INPUT); }}OUTPUT: -foo-foo-foo-

Per sostituire solo la prima occorrenza del modello, è sufficiente chiamare replaceFirst invece di replaceAll. Accetta lo stesso parametro.

46

Regular Expression

Utilizzo di appendReplacement(StringBuffer, String) e appendTail(StringBuffer)La classe Matcher fornisce anche i metodi appendReplacement e appendTail per la sostituzione del testo. Il seguente esempio, RegexDemo.java, utilizza questi due metodi per ottenere lo stesso effetto di replaceAll.import java.util.regex.Pattern;import java.util.regex.Matcher;public class RegexDemo { private static String REGEX = "a*b"; private static String INPUT = "aabfooaabfooabfoob"; private static String REPLACE = "-"; public static void main(String[] args) { Pattern p = Pattern.compile(REGEX); Matcher m = p.matcher(INPUT); // get a matcher object StringBuffer sb = new StringBuffer(); while(m.find()){m.appendReplacement(sb,REPLACE);} m.appendTail(sb); System.out.println(sb.toString()); }}

OUTPUT: -foo-foo-foo-

Metodi Equivalenti a Matcher in java.lang.StringPer comodità, la classe String imita un paio di metodi Matcher anche:

• public String replaceFirst(String regex, replacement String): Sostituisce la prima sottostringa di questa stringa che corrisponde all'espressione regolare data con la sostituzione dato. L'invocazione di questo metodo di forma str.replaceFirst(regex, repl) produce esattamente lo stesso risultato del Pattern.compile (regex).matcher(str).replaceFirst(repl)

• public String replaceAll(String regex, replacement String): Sostituisce ogni sottostringa di questa stringa che corrisponde all'espressione regolare data con la sostituzione data. L'invocazione di questo metodo di formato str.replaceAll(regex,repl)produce esattamente lo stesso risultato dell'espressionePattern.compile(regex).matcher(str).replaceAll(repl)

47

Regular Expression

Metodi della classe PatternSyntaxExceptionA PatternSyntaxException è un'eccezione unchecked che indica un errore di sintassi in un modello di espressione regolare. La classe PatternSyntaxException fornisce i seguenti metodi per aiutare a determinare cosa è andato storto:

• public String getDescription(): Recupera la descrizione dell'errore.• public int getIndex(): Recupera l'indice di errore.• public String getPattern(): Recupera il pattern errata espressione regolare.• public String getMessage(): Restituisce un multi-stringa della riga contenente

la descrizione dell'errore di sintassi ed il suo indice, l'erronea espressioni regolari pattern e una indicazione visiva dell'indice di errore all'interno del modello.

Il seguente codice sorgente, RegexTestHarness2.java, aggiorna il nostro test harness per verificare malformati espressioni regolari: import java.io.Console;import java.util.regex.Pattern;import java.util.regex.Matcher;import java.util.regex.PatternSyntaxException;

public class RegexTestHarness2 { public static void main(String[] args){ Pattern pattern = null; Matcher matcher = null; Console console = System.console(); if (console == null) { System.err.println("No console."); System.exit(1);} while (true) { try{pattern= Pattern.compile(console.readLine("%nEnter your regex: ")); matcher=pattern.matcher(console.readLine("Enter input string to search: ")); } catch(PatternSyntaxException pse){ console.format("There is a problem"+" with the regular expression!%n"); console.format("The pattern in question is: %s%n", pse.getPattern()); console.format("The description is: %s%n",pse.getDescription()); console.format("The message is: %s%n",pse.getMessage()); console.format("The index is: %s%n",pse.getIndex()); System.exit(0); } boolean found = false; while (matcher.find()) {console.format("I found the text"+"\"%s\" starting at "+"index %d and ending at index %d.%n", matcher.group(),matcher.start(),matcher.end()); found = true; } if(!found){ console.format("No match found.%n"); } } }}

48

Regular Expression

Per eseguire questo test, immettere? I) foo come l'espressione regolare. Questo errore è uno scenario comune in cui il programmatore ha dimenticato la parentesi di apertura nell'espressione bandiera incorporato (? I). In questo modo si producono i seguenti risultati: Enter your regex: ?i)There is a problem with the regular expression!The pattern in question is: ?i)The description is: Dangling meta character '?'The message is: Dangling meta character '?' near index 0?i)^The index is: 0

Da questa uscita, possiamo vedere che l'errore di sintassi è un dangling metacarattere (il punto interrogativo) in corrispondenza dell'indice 0. Una parentesi aperta manca è il colpevole.

Supporto UnicodeA partire dalla versione JDK 7, Regular Expression pattern matching ha ampliato le funzionalità per supportare Unicode 6,0.

• Corrispondenza di un punto specifico codice• Proprietà dei caratteri Unicode

Corrispondenza di un punto specifico codiceÈ possibile abbinare un punto specifico codice Unicode utilizzando una sequenza di escape della forma \uFFFF, dove FFFF è il valore esadecimale del punto codice che si desidera abbinare. Ad esempio, \u6771 corrisponde al carattere Han per est.

In alternativa, è possibile specificare un punto di codice utilizzando Perl-style notazione esadecimale, \x {...}. Ad esempio:

Esadecimale Il motivo String = "\x {" + Integer.toHexString (codepoint) + "}";

Proprietà dei caratteri UnicodeCiascun carattere Unicode, oltre al suo valore, ha certi attributi o proprietà. È possibile abbinare un singolo carattere che appartiene a una categoria particolare con l'espressione \ p {prop}. È possibile abbinare un singolo carattere che non appartiene ad una categoria particolare con l'espressione \P {prop}. I tre tipi di proprietà supportati sono gli script, i blocchi, e una categoria "generale".

49

Regular Expression

ScriptPer determinare se un punto di codice appartiene ad uno script specifico, è possibile utilizzare la parola chiave script, o la forma sc breve, per esempio, \p {} = script di Hiragana. In alternativa, è possibile anteporre il nome dello script con la stringa è, ad esempio \p {} IsHiragana. Nomi degli script supportati da validi modello sono quelli accettati da UnicodeScript.forName.

BlocchiUn blocco può essere specificato usando la parola chiave di blocco, o la forma blk breve, per esempio, \p {blocco} = mongolo. In alternativa, è possibile anteporre al nome del blocco con la stringa In, ad esempio \p {} InMongolian. Nomi dei blocchi supportate da validi modello sono quelli accettati da UnicodeBlock.forName.

General CategoryLe categorie possono essere specificati con il prefisso opzionale. Ad esempio, ISL corrisponde alla categoria di lettere Unicode. Le categorie possono anche essere specificati utilizzando la parola chiave general_category, o il breve modulo gc. Ad esempio, una lettera maiuscola può essere abbinato con general_category = Lu o gc = Lu. Categorie supportati sono quelli dello standard Unicode nella versione specificata dalla classe di caratteri.

Risorse aggiuntiveOra che hai completato questa lezione sulle espressioni regolari, probabilmente scoprirete che i vostri riferimenti principali saranno la documentazione delle API per le seguenti classi: modello e Matcher e PatternSyntaxException.

Per una descrizione più precisa del comportamento dei costrutti delle espressioni regolari, si consiglia di leggere i Mastering Regular Expressions libro di Jeffrey EF Friedl.

50

Regular Expression

Questions and Exercises: Regular Expressions

Questions1. What are the three public classes in the java.util.regex package?

Describe the purpose of each. 2. Consider the string literal "foo". What is the start index? What is the end

index? Explain what these numbers mean. 3. What is the difference between an ordinary character and a metacharacter?

Give an example of each. 4. How do you force a metacharacter to act like an ordinary character? 5. What do you call a set of characters enclosed in square brackets? What is it

for? 6. Here are three predefined character classes: \d, \s, and \w. Describe each

one, and rewrite it using square brackets. 7. For each of \d, \s, and \w, write two simple expressions that match the

opposite set of characters. 8. Consider the regular expression (dog){3}. Identify the two subexpressions.

What string does the expression match?

Exercises1. Use a backreference to write an expression that will match a person's name

only if that person's first name and last name are the same.

51

Regular Expression

Answers to Questions and Exercises:

Questions1. Question: What are the three public classes in the java.util.regex package?

Describe the purpose of each. Answer:

• Pattern instances are compiled representations of regular expressions. • Matcher instances are engines that interpret patterns and perform match

operations against input strings. • PatternSyntaxException defines an unchecked exception indicating a

syntax error in a regular expression. 2. Question: Consider the string literal "foo". What is the start index? What is the

end index? Explain what these numbers mean. Answer: Each character in the string resides in its own cell. Index positions point between cells. The string "foo" starts at index 0 and ends at index 3, even though the characters only occupy cells 0, 1, and 2.

3. Question: What is the difference between an ordinary character and a metacharacter? Give an example of each. Answer: An ordinary character in a regular expression matches itself. A metacharacter is a special character that affects the way a pattern is matched. The letter A is an ordinary character. The punctuation mark . is a metacharacter that matches any single character.

4. Question: How do you force a metacharacter to act like an ordinary character? Answer: There are two ways:

• Precede the metacharacter with a backslash (\); • Enclose the metacharacter within the quote expressions, \Q (at the

beginning) and \E (at the end). 5. Question: What do you call a set of characters enclosed in square brackets?

What is it for? Answer: This is a character class. It matches any single character that is in the class of characters specified by the expression between the brackets.

6. Question: Here are three predefined character classes: \d, \s, and \w. Describe each one, and rewrite it using square brackets. Answer:\d Matches any digit. [0-9]\s Matches any white space character. [ \t\n-x0B\f\r]\w Matches any word character. [a-zA-Z_0-9]

7. Question: For each of \d, \s, and \w, write two simple expressions that match the opposite set of characters.

52

Regular Expression

Answer:\d \D [^\d]\s \S [^\s]\w \W [^\w]

8. Question: Consider the regular expression (dog){3}. Identify the two subexpressions. What string does the expression match? Answer: The expression consists of a capturing group, (dog), followed by a greedy quantifier {3}. It matches the string "dogdogdog".

Exercises

• Exercise: Use a backreference to write an expression that will match a person's name only if that person's first name and last name are the same. Solution: ([A-Z][a-zA-Z]*)\s\1

http://docs.oracle.com/javase/tutorial/essential/regex/index.html

53

Regular Expression

Indice generaleEspressioni regolari..............................................................................................................................1Java: Espressioni regolari.....................................................................................................................3Espressione regolare.............................................................................................................................9

Indice...............................................................................................................................................9Definizione ......................................................................................................................................9Storia .............................................................................................................................................10Espressioni regolari nei linguaggi formali ....................................................................................10Impiego delle espressioni regolari ................................................................................................11Sintassi ..........................................................................................................................................11

Espressioni regolari tradizionali di UNIX ................................................................................11Esempi di quantificatori ...........................................................................................................14

Introduzione........................................................................................................................................17Come sono le espressioni regolari rappresentati in questo pacchetto?..........................................17

test Harness.........................................................................................................................................18Stringhe letterali.................................................................................................................................20

metacaratteri...................................................................................................................................21classi di caratteri.................................................................................................................................21

classi Semplici...............................................................................................................................22Negazione......................................................................................................................................22Campi.............................................................................................................................................23Unioni............................................................................................................................................24Intersezioni.....................................................................................................................................24Sottrazione.....................................................................................................................................25

Classi di caratteri predefiniti..............................................................................................................26quantificatori.......................................................................................................................................28

Confronti a Lunghezza-Zero..........................................................................................................29Catturare gruppi e le classi di caratteri con Quantificatori............................................................32Differenze Tra quantificatori avido, riluttante, e possessivo. .......................................................32

Gruppi di cattura.................................................................................................................................34Numerazione..................................................................................................................................34Backreferences...............................................................................................................................35

Adattatori Boundary (di confine).......................................................................................................35Metodi della classe Pattern.................................................................................................................37

Creazione di un modello con flags................................................................................................37Espressioni Flag incorporate..........................................................................................................39Utilizzo del metodo matches(String, CharSequence)....................................................................40Utilizzo del metodo split(String)...................................................................................................40Altri metodi di utilità.....................................................................................................................42Metodi equivalenti a pattern di java.lang.String............................................................................42

Metodi della classe Matcher...............................................................................................................43Metodi Indice.................................................................................................................................43Metodi di studio.............................................................................................................................43Metodi di ricambio.........................................................................................................................44Uso dei metodi di inizio e fine.......................................................................................................44Uso dei metodi matches e lookingAt.............................................................................................45Utilizzo di replaceFirst(String) e replaceAll(String).....................................................................46Utilizzo di appendReplacement(StringBuffer, String) e appendTail(StringBuffer)......................47

54

Regular Expression

Metodi Equivalenti a Matcher in java.lang.String.........................................................................47Metodi della classe PatternSyntaxException......................................................................................48Supporto Unicode...............................................................................................................................49

Corrispondenza di un punto specifico codice................................................................................49Proprietà dei caratteri Unicode......................................................................................................49Script..............................................................................................................................................50Blocchi...........................................................................................................................................50General Category...........................................................................................................................50

Risorse aggiuntive..............................................................................................................................50Questions and Exercises: Regular Expressions..................................................................................51

Questions.......................................................................................................................................51Exercises........................................................................................................................................51

Answers to Questions and Exercises:.................................................................................................52Questions.......................................................................................................................................52Exercises........................................................................................................................................53

55