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: 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
Altri link che potrebbero interessarti
  • Utilizzare un JButton in Java Swing
  • Utilizzare HTML in componenti Java Swing
  • Numeri casuali in java
  • Modalità Full Screen Exclusive in java
  • Leggere un file di testo in java
  • Le variabili atomiche in java
  • Le classi anonime
  • Java Database MySql
  • Java Cursor Mouse
  • Import Static Java
  • Implementare un Singleton
  • Implementare un KeyListener in java Swing
  • Implementare il System.out su una JTextArea
  • Il costrutto if in java
  • Il costrutto foreach in java
  • Il blocco static
  • Creare una ToolBar in Java Swing
  • Chiudere le applicazioni Java Swing
  • Bordo con titolo in Java Swing
  • Background Image per componenti Java Swing