Java Regex

Le espressioni regolari o semplicemente Regex (dall'inglese Regular Expression) rappresentano un potentissimo strumento per l'elaborazione di testi sia semplici che complessi. Ci permettono di riconoscere alcuni frammenti di stringhe che seguono una certa regola sintattica all'interno di un testo.

Come tutti i linguaggi di programmazione anche Java dispone di alcune classi per la gestione delle espressioni regolari introdotte a partire dalla versione 1.4 della Java Standard Edition con il package java.util.regex. Vediamo adesso, non tanto come definire tali espressioni che è un argomento alquanto complesso, ma bensi come utilizzarli in java. Le classi necessarie per la definizione e l'elaborazione delle Regex sono due:

• java.util.regex.Pattern
• java.util.regex.Matcher

La classe Pattern si occupa di compilare l'espressione regolare da applicare successivamente ad un testo. Per ottenere un'istanza di questa classe si effettua una chiamata al metodo statico compile() che ha come parametro la regex:

Pattern pattern = Pattern.compile("([0-9]+)");

Quindi ottenuta l' istanza passiamo ad elaborare il testo con il metodo matcher():

Matcher match = pattern.matcher("Testo da elaborare");

La classe Matcher incapsula tutto il risultato dell'elaborazione, fornendo i metodi necessari ad iterare le espressioni identificate nel testo ed accedere ai sottogruppi di esse. Per capire il concetto di sottogruppo vediamo ad esempio un espressione regolare di questo tipo:

((A)(B(C)))

Ogni volta che verrà identificata questa espressione all'interno di un testo, avremmo 4 sottogruppi:

1. ((A)(B(C)))
2. (A)
3. (B(C))
4. (C)

I metodi essenzili della classe Matcher sono:

• boolean find():cerca la sottosequenza successiva identificata nel testo
• boolean matches(): ritorna true se l'intero testo corrisponde all'espressione regolare
• String group(int n): ritorna il sottogruppo n all'interno della sottosequenza identificata
• String group(): ritorna l'intera sottosequenza identificata

Quindi una volta elaborato un testo con il pattern si iterano le espressioni con il metodo find() fino a quando il metodo non ritorna false. Ad ogni iterazione si può accedere ai sottogruppi definiti nell'espressione regolare. Qui potete vedere un esempio che estrae il testo all'interno del tag HTML span:

public static void main(String [] argv) {
  String text = "<span>a</span>testo<span>b</span>altro testo<span>c</span>";
  Pattern pattern = Pattern.compile("<span>([^<]+)</span>");
  Matcher matcher = pattern.matcher(text);
  while(matcher.find()) {
    System.out.println("Sottosequenza : "+matcher.group());
    System.out.println("Sottogruppo 1 : "+matcher.group(1));
  }
}

Da qui l'output generato:

Sottoseuqenza : <span>a</span>
Sottogruppo 1 : a
Sottoseuqenza : <span>b</span>
Sottogruppo 1 : b
Sottoseuqenza : <span>c</span>
Sottogruppo 1 : c

Una regex per l'email

Sfruttiamo adesso la potenza delle espressioni regolari per creare un metodo che controlla la correttezza sintattica di un'email:

class DemoRegex {
  public static boolean vrificaEmail(String email) {
    Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+");
    Matcher matcher = pattern.matcher(email);
    if(matcher.matches()) return true;
    else return false;
  }
}

Il metodo matches() a differenza del metodo find() verifica che l'intera stringa rispetti esattamente l'espressione regolare. Se ad esempio avessimo utilizzato find() per la verifica otterremmo true inserendo anche una email sbagliata ma che al suo interno contiene una sottostringa esatta come per esempio:

email@email.com@email.it