Java - espressioni regolari

Java fornisce il pacchetto java.util.regex per la corrispondenza dei modelli con le espressioni regolari. Le espressioni regolari Java sono molto simili al linguaggio di programmazione Perl e molto facili da imparare.

Un'espressione regolare è una sequenza speciale di caratteri che consente di abbinare o trovare altre stringhe o gruppi di stringhe, utilizzando una sintassi specializzata contenuta in un modello. Possono essere utilizzati per cercare, modificare o manipolare testo e dati.

Il pacchetto java.util.regex consiste principalmente delle seguenti tre classi:

• Pattern Class- Un oggetto Pattern è una rappresentazione compilata di un'espressione regolare. La classe Pattern non fornisce costruttori pubblici. Per creare un pattern, devi prima richiamare una delle sue statiche pubblichecompile()metodi, che restituiranno quindi un oggetto Pattern. Questi metodi accettano un'espressione regolare come primo argomento.

• Matcher Class- Un oggetto Matcher è il motore che interpreta il modello ed esegue operazioni di corrispondenza su una stringa di input. Come la classe Pattern, Matcher non definisce alcun costruttore pubblico. Ottieni un oggetto Matcher invocando il filematcher() metodo su un oggetto Pattern.

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

Acquisizione di gruppi

La cattura di gruppi è un modo per trattare più personaggi come una singola unità. Vengono creati inserendo i caratteri da raggruppare all'interno di una serie di parentesi. Ad esempio, l'espressione regolare (cane) crea un singolo gruppo contenente le lettere "d", "o" e "g".

I gruppi di cattura vengono numerati contando le loro parentesi di apertura da sinistra a destra. Nell'espressione ((A) (B (C))), ad esempio, ci sono quattro di questi gruppi:

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

Per scoprire quanti gruppi sono presenti nell'espressione, chiama il metodo groupCount su un oggetto matcher. Il metodo groupCount restituisce un fileint mostrando il numero di gruppi di cattura presenti nel modello del matcher.

C'è anche un gruppo speciale, il gruppo 0, che rappresenta sempre l'intera espressione. Questo gruppo non è incluso nel totale riportato da groupCount.

Example

L'esempio seguente illustra come trovare una stringa di cifre dalla stringa alfanumerica data:

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

public class RegexMatches {

   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      }else {
         System.out.println("NO MATCH");
      }
   }
}

Questo produrrà il seguente risultato:

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Sintassi delle espressioni regolari

Ecco la tabella che elenca tutta la sintassi dei metacaratteri delle espressioni regolari disponibile in Java:

Sottoespressione	Partite
^	Corrisponde all'inizio della riga.
$	Corrisponde alla fine della riga.
.	Corrisponde a qualsiasi carattere singolo tranne la nuova riga. Utilizzandom opzione consente di abbinare anche la nuova riga.
[...]	Corrisponde a qualsiasi singolo carattere tra parentesi.
[^ ...]	Corrisponde a qualsiasi carattere singolo non tra parentesi.
\UN	Inizio dell'intera stringa.
\ z	Fine dell'intera stringa.
\ Z	Fine dell'intera stringa tranne il terminatore di riga finale consentito.
ri*	Corrisponde a 0 o più occorrenze dell'espressione precedente.
re +	Corrisponde a 1 o più elementi precedenti.
ri?	Corrisponde a 0 o 1 occorrenza dell'espressione precedente.
re {n}	Corrisponde esattamente al numero n di occorrenze dell'espressione precedente.
re {n,}	Corrisponde a n o più occorrenze dell'espressione precedente.
re {n, m}	Trova almeno n e al massimo m occorrenze dell'espressione precedente.
a | b	Corrisponde a a o b.
(ri)	Raggruppa le espressioni regolari e ricorda il testo corrispondente.
(?: re)	Raggruppa le espressioni regolari senza ricordare il testo corrispondente.
(?> re)	Corrisponde al modello indipendente senza backtracking.
\ w	Corrisponde ai caratteri della parola.
\ W	Corrisponde ai caratteri non di parole.
\S	Corrisponde allo spazio bianco. Equivalente a [\ t \ n \ r \ f].
\S	Corrisponde allo spazio non bianco.
\ d	Corrisponde alle cifre. Equivalente a [0-9].
\ D	Corrisponde alle non cifre.
\UN	Corrisponde all'inizio della stringa.
\ Z	Corrisponde alla fine della stringa. Se esiste una nuova riga, corrisponde appena prima della nuova riga.
\ z	Corrisponde alla fine della stringa.
\ G	Corrisponde al punto in cui è terminata l'ultima partita.
\ n	Riferimento a ritroso per acquisire il numero di gruppo "n".
\ b	Corrisponde ai confini della parola quando si trova al di fuori delle parentesi. Corrisponde al backspace (0x08) quando è all'interno delle parentesi.
\ B	Corrisponde ai confini non di parole.
\ n, \ t, ecc.	Trova nuove righe, ritorni a capo, tabulazioni, ecc.
\ Q	Fuga (virgolette) tutti i caratteri fino a \ E.
\ E	Termina la citazione iniziata con \ Q.

Metodi della classe Matcher

Ecco un elenco di metodi di istanza utili:

Metodi di indice

I metodi di indice forniscono utili valori di indice che mostrano esattamente dove è stata trovata la corrispondenza nella stringa di input -

Sr.No.	Metodo e descrizione
1	public int start() Restituisce l'indice iniziale della corrispondenza precedente.
2	public int start(int group) Restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente.
3	public int end() Restituisce l'offset dopo l'ultimo carattere trovato.
4	public int end(int group) Restituisce l'offset dopo l'ultimo carattere della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente.

Metodi di studio

I metodi di studio esaminano la stringa di input e restituiscono un valore booleano che indica se il modello viene trovato o meno -

Sr.No.	Metodo e descrizione
1	public boolean lookingAt() Tenta di far corrispondere la sequenza di input, a partire dall'inizio della regione, rispetto al modello.
2	public boolean find() Tenta di trovare la successiva sottosequenza della sequenza di input che corrisponde al modello.
3	public boolean find(int start) Reimposta questo matcher e quindi tenta di trovare la sottosequenza successiva della sequenza di input che corrisponde al modello, a partire dall'indice specificato.
4	public boolean matches() Tenta di far corrispondere l'intera regione rispetto al modello.

Metodi di sostituzione

I metodi di sostituzione sono metodi utili per sostituire il testo in una stringa di input -

Sr.No.	Metodo e descrizione
1	public Matcher appendReplacement(StringBuffer sb, String replacement) Implementa un passaggio di aggiunta e sostituzione non terminale.
2	public StringBuffer appendTail(StringBuffer sb) Implementa un passaggio di aggiunta e sostituzione del terminale.
3	public String replaceAll(String replacement) Sostituisce ogni sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
4	public String replaceFirst(String replacement) Sostituisce la prima sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
5	public static String quoteReplacement(String s) Restituisce una stringa sostitutiva letterale per la stringa specificata. Questo metodo produce una stringa che funzionerà come una sostituzione letterales nel metodo appendReplacement della classe Matcher.

I metodi di inizio e fine

Di seguito è riportato l'esempio che conta il numero di volte in cui la parola "gatto" appare nella stringa di input:

Example

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

public class RegexMatches {

   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";

   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      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());
      }
   }
}

Questo produrrà il seguente risultato:

Output

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

Puoi vedere che questo esempio utilizza i confini delle parole per garantire che le lettere "c" "a" "t" non siano semplicemente una sottostringa in una parola più lunga. Fornisce anche alcune informazioni utili su dove si è verificata la corrispondenza nella stringa di input.

Il metodo start restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante la precedente operazione di corrispondenza e la fine restituisce l'indice dell'ultimo carattere corrispondente, più uno.

Le partite e i metodi di ricerca

I metodi Match e LookingAt tentano entrambi di trovare una corrispondenza tra una sequenza di input e un pattern. La differenza, tuttavia, è che le corrispondenze richiedono la corrispondenza dell'intera sequenza di input, mentre lookingAt no.

Entrambi i metodi iniziano sempre all'inizio della stringa di input. Ecco l'esempio che spiega la funzionalità:

Example

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

public class RegexMatches {

   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[] ) {
      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());
   }
}

Questo produrrà il seguente risultato:

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

I metodi replaceFirst e replaceAll

I metodi replaceFirst e replaceAll sostituiscono il testo che corrisponde a una data espressione regolare. Come indicano i nomi, replaceFirst sostituisce la prima occorrenza e replaceAll sostituisce tutte le occorrenze.

Ecco l'esempio che spiega la funzionalità:

Example

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

public class RegexMatches {

   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);
   }
}

Questo produrrà il seguente risultato:

Output

The cat says meow. All cats say meow.

I metodi appendReplacement e appendTail

La classe Matcher fornisce anche metodi appendReplacement e appendTail per la sostituzione del testo.

Ecco l'esempio che spiega la funzionalità:

Example

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

public class RegexMatches {

   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);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Questo produrrà il seguente risultato:

Output

-foo-foo-foo-

Metodi di classe PatternSyntaxException

Una PatternSyntaxException è un'eccezione non controllata che indica un errore di sintassi in un modello di espressione regolare. La classe PatternSyntaxException fornisce i seguenti metodi per aiutarti a determinare cosa è andato storto:

Sr.No.	Metodo e descrizione
1	public String getDescription() Recupera la descrizione dell'errore.
2	public int getIndex() Recupera l'indice di errore.
3	public String getPattern() Recupera il modello di espressione regolare errato.
4	public String getMessage() Restituisce una stringa su più righe contenente la descrizione dell'errore di sintassi e il relativo indice, il modello di espressione regolare errato e un'indicazione visiva dell'indice di errore all'interno del modello.