Java Regex - Guida rapida

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.

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.

Esempio

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:

Produzione

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

introduzione

Il java.util.regex.MatchResultl'interfaccia rappresenta il risultato di un'operazione di abbinamento. Questa interfaccia contiene metodi di query utilizzati per determinare i risultati di una corrispondenza con un'espressione regolare. I confini della partita, i gruppi e i confini del gruppo possono essere visualizzati ma non modificati tramite MatchResult.

Dichiarazione dell'interfaccia

Di seguito è riportata la dichiarazione per java.util.regex.MatchResult interfaccia -

public interface MatchResult

Metodi di interfaccia

Suor n	Metodo e descrizione
1	avere intenzione() Restituisce l'offset dopo l'ultimo carattere trovato.
2	int end (int gruppo) Restituisce l'offset dopo l'ultimo carattere della sottosequenza acquisita dal gruppo specificato durante questa corrispondenza.
3	Gruppo di stringhe () Restituisce la sottosequenza di input corrispondente alla corrispondenza precedente.
4	Gruppo di stringhe (gruppo int) Restituisce la sottosequenza di input acquisita dal gruppo specificato durante la precedente operazione di corrispondenza.
5	int groupCount () Restituisce il numero di gruppi di acquisizione nel modello del risultato di questa corrispondenza.
6	int start () Restituisce l'indice iniziale della corrispondenza.
7	int start (int gruppo) Restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante questa corrispondenza.

introduzione

Il java.util.regex.Pattern class rappresenta una rappresentazione compilata di un'espressione regolare.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per java.util.regex.Pattern classe -

public final class Pattern
   extends Object
      implements Serializable

Campo

Di seguito sono riportati i campi per java.util.regex.Duration classe -

• static int CANON_EQ - Abilita l'equivalenza canonica.

• static int CASE_INSENSITIVE - Abilita la corrispondenza senza distinzione tra maiuscole e minuscole.

• static int COMMENTS - Consente spazi bianchi e commenti nel pattern.

• static int DOTALL - Abilita la modalità dotall.

• static int LITERAL - Abilita l'analisi letterale del pattern.

• static int MULTILINE - Abilita la modalità multilinea.

• static int UNICODE_CASE - Abilita la piegatura del caso compatibile con Unicode.

• static int UNICODE_CHARACTER_CLASS - Abilita la versione Unicode delle classi di caratteri predefinite e delle classi di caratteri POSIX.

• static int UNIX_LINES - Abilita la modalità linee Unix.

Metodi di classe

Suor n	Metodo e descrizione
1	Compilazione di pattern statici (stringa regex) Compila l'espressione regolare data in un pattern.
2	Compilazione di pattern statici (regex di stringa, flag int) Compila l'espressione regolare data in un pattern con i flag dati.
3	int flags () Restituisce i flag di corrispondenza di questo modello.
4	Matcher matcher (input CharSequence) Crea un matcher che abbinerà l'input fornito a questo modello.
5	corrispondenze booleane statiche (stringa regex, input CharSequence) Compila l'espressione regolare data e tenta di confrontare l'input fornito con essa.
6	Schema corde () Restituisce l'espressione regolare da cui è stato compilato questo modello.
7	static String quote (String s) Restituisce una stringa di pattern letterale per la stringa specificata.
8	String [] split (CharSequence input) Divide la sequenza di input data attorno alle corrispondenze di questo modello.
9	String [] split (CharSequence input, int limit) Divide la sequenza di input data attorno alle corrispondenze di questo modello.
10	String toString () Restituisce la rappresentazione di stringa di questo modello.

Metodi ereditati

Questa classe eredita i metodi dalle seguenti classi:

• Java.lang.Object

introduzione

Il java.util.regex.Matcher class agisce come un motore che esegue le operazioni di corrispondenza su una sequenza di caratteri interpretando un Pattern.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per java.util.regex.Matcher classe -

public final class Matcher
   extends Object
      implements MatchResult

Metodi di classe

Suor n	Metodo e descrizione
1	Matcher appendReplacement (StringBuffer sb, Sostituzione di stringhe) Implementa un passaggio di aggiunta e sostituzione non terminale.
2	StringBuffer appendTail (StringBuffer sb) Implementa un passaggio di aggiunta e sostituzione del terminale.
3	avere intenzione() Restituisce l'offset dopo l'ultimo carattere trovato.
4	int end (int gruppo) Restituisce l'offset dopo l'ultimo carattere della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente.
5	booleano find () Tenta di trovare la successiva sottosequenza della sequenza di input che corrisponde al modello.
6	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.
7	Gruppo di stringhe () Restituisce la sottosequenza di input acquisita dal gruppo specificato durante la precedente operazione di corrispondenza.
8	Gruppo di stringhe (nome della stringa) Restituisce la sottosequenza di input acquisita dal gruppo di acquisizione denominato specificato durante l'operazione di corrispondenza precedente.
9	int groupCount () Restituisce il numero di gruppi di acquisizione nel pattern di questo matcher.
10	booleano hasAnchoringBounds () Interroga l'ancoraggio dei limiti della regione per questo matcher.
11	booleano hasTransparentBounds () Interroga la trasparenza dei limiti della regione per questo matcher.
12	booleano hitEnd () Restituisce vero se la fine dell'input è stata raggiunta dal motore di ricerca nell'ultima operazione di corrispondenza eseguita da questo abbinatore.
13	boolean lookingAt () Tenta di far corrispondere la sequenza di input, a partire dall'inizio della regione, rispetto al modello.
14	corrispondenze booleane () Tenta di far corrispondere l'intera regione rispetto al modello.
15	Motivo pattern () Restituisce il modello interpretato da questo abbinatore.
16	static String quoteReplacement (String s) Restituisce una stringa sostitutiva letterale per la stringa specificata.
17	Matcher region (int inizio, int fine) Imposta i limiti della regione di questo matcher.
18	int regionEnd () Riporta l'indice finale (esclusivo) della regione di questo matcher.
19	int regionStart () Segnala l'indice iniziale della regione di questo matcher.
20	String replaceAll (Sostituzione stringa) Sostituisce ogni sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
21	String replaceFirst (Sostituzione stringa) Sostituisce la prima sottosequenza della sequenza di input che corrisponde al modello con la stringa di sostituzione data.
22	booleano requireEnd () Restituisce vero se più input possono cambiare una corrispondenza positiva in una negativa.
23	Ripristino matcher () Reimposta questo matcher.
24	Ripristino matcher (input CharSequence) Reimposta questo matcher con una nuova sequenza di input.
25	int start () Restituisce l'indice iniziale della corrispondenza precedente.
26	int start (int gruppo) Restituisce l'indice iniziale della sottosequenza acquisita dal gruppo specificato durante l'operazione di corrispondenza precedente.
27	MatchResult toMatchResult () Restituisce lo stato di corrispondenza di questo matcher come MatchResult.
28	String toString () Restituisce la rappresentazione di stringa di questo matcher.
29	Uso del matcherAnchoringBounds (booleano b) Imposta l'ancoraggio dei confini della regione per questo matcher.
30	Matcher usePattern (Pattern newPattern) Modifica il pattern utilizzato da questo Matcher per trovare le corrispondenze.
31	Matcher useTransparentBounds (booleano b) Imposta la trasparenza dei confini della regione per questo matcher.

Metodi ereditati

Questa classe eredita i metodi dalle seguenti classi:

• Java.lang.Object

introduzione

Il java.util.regex.PatternSyntaxException class rappresenta un'eccezione non controllata generata per indicare un errore di sintassi in un modello di espressione regolare.

Dichiarazione di classe

Di seguito è riportata la dichiarazione per java.util.regex.PatternSyntaxException classe -

public class PatternSyntaxException
   extends IllegalArgumentException

Costruttori

Suor n	Metodo e descrizione
1	PatternSyntaxException(String desc, String regex, int index) Costruisce una nuova istanza di questa classe.

Metodi di classe

Suor n	Metodo e descrizione
1	String getDescription() Recupera la descrizione dell'errore.
2	int getIndex() Recupera l'indice di errore.
3	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.
4	String getPattern() Recupera il modello di espressione regolare errato.

Metodi ereditati

Questa classe eredita i metodi dalle seguenti classi:

• Java.lang.Throwable
• Java.lang.Object

Esempio

L'esempio seguente mostra l'utilizzo dei metodi della classe java.util.regex.Pattern.PatternSyntaxException.

package com.tutorialspoint;

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

public class PatternSyntaxExceptionDemo {
   private static String REGEX = "[";
   private static String INPUT = "The dog says meow " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);
         
         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT); 
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

Compiliamo ed eseguiamo il programma sopra, questo produrrà il seguente risultato:

PatternSyntaxException: 
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

Di seguito sono riportati vari esempi di corrispondenza dei caratteri utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	X Il carattere x
2	\\ Il carattere barra rovesciata
3	\ 0n Il carattere con valore ottale 0n (0 ≤ n ≤ 7)
4	\ 0nn Il carattere con valore ottale 0nn (0 ≤ n ≤ 7)
5	\ 0mnn Il carattere con valore ottale 0mnn (0 ≤ m ≤ 3, 0 ≤ n ≤ 7)
6	\ xhh Il carattere con valore esadecimale 0xhh
7	\ uhhhh Il carattere con valore esadecimale 0xhhhh
8	\ t Il carattere di tabulazione ("\ u0009")
9	\ n Il carattere di nuova riga (avanzamento riga) ("\ u000A")
10	\ r Il carattere di ritorno a capo ("\ u000D")
11	\ f Il carattere di avanzamento modulo ("\ u000C")

Di seguito sono riportati vari esempi di corrispondenza delle classi di caratteri utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	[abc] a, b o c (classe semplice).
2	[^ abc] Qualsiasi carattere tranne a, b o c (negazione).
3	[a-zA-Z] dalla a alla z oppure dalla A alla Z, inclusi (intervallo).
4	[annuncio [mp]] dalla a alla do, o dalla m alla p: [a-dm-p] (unione).
5	[az && [def]] d, e o f (intersezione).
6	[az && [^ bc]] dalla a alla z, ad eccezione di bec: [ad-z] (sottrazione)
7	[az && [^ mp]] dalla a alla z e non dalla m alla p: [a-lq-z] (sottrazione).

Di seguito sono riportati vari esempi di corrispondenza tra classi di caratteri predefinite utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	. Qualsiasi carattere (può o non può corrispondere ai terminatori di riga).
2	\ d Una cifra: [0-9].
3	\ D Una non cifra: [^ 0-9].
4	\S Uno spazio vuoto: [\ t \ n \ x0B \ f \ r]
5	\S Un carattere diverso da uno spazio bianco: [^ \ s].
6	\ w Una parola di carattere: [a-zA-Z_0-9].
7	\ W Un carattere non composto da una parola: [^ \ w]

Di seguito sono riportati vari esempi di corrispondenza delle classi di caratteri POSIX utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	\ p {inferiore} Un carattere alfabetico minuscolo: [az].
2	\ p {Superiore} Un carattere alfabetico maiuscolo: [AZ].
3	\ p {ASCII} Tutti ASCII: [\ x00- \ x7F].
4	\ p {Alpha} Un carattere alfabetico: [\ p {Lower} \ p {Upper}].
5	\ p {Digit} Una cifra decimale: [0-9].
6	\ p {Alnum} Un carattere alfanumerico: [\ p {Alpha} \ p {Digit}].
7	\ p {Punct} Punteggiatura: uno tra! "# $% & '() * +, -. / :; <=>? @ [\] ^ _> {|} <.
8	\ p {Grafico} Un carattere visibile: [\ p {Alnum} \ p {Punct}].
9	\ p {Stampa} Un carattere stampabile: [\ p {Graph} \ x20].
10	\ p {Vuoto} Uno spazio o una tabulazione: [\ t].
11	\ p {XDigit} Una cifra esadecimale: [0-9a-fA-F].
12	\ p {Spazio} Un carattere di spazio bianco: [\ t \ n \ x0B \ f \ r].

Di seguito sono riportati vari esempi di corrispondenza tra classi di caratteri JAVA utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	\ p {javaLowerCase} Equivalente a java.lang.Character.isLowerCase ().
2	\ p {javaUpperCase} Equivalente a java.lang.Character.isUpperCase ().
3	\ p {javaWhitespace} Equivalente a java.lang.Character.isWhitespace ().
4	\ p {javaMirrored} Equivalente a java.lang.Character.isMirrored ().

Di seguito sono riportati vari esempi di corrispondenza delle classi di caratteri Unicode utilizzando espressioni regolari in java.

Suor n	Costruisci e abbina
1	\ p {IsLatin} Un personaggio in caratteri latini.
2	\ p {in greco} Un personaggio nel blocco greco.
3	\ p {Lu} Una lettera maiuscola.
4	\ p {IsAlphabetic} Un carattere alfabetico (proprietà binaria).
5	\ p {Sc} Un simbolo di valuta.
6	\ P {InGreek} Qualsiasi carattere tranne uno nel blocco greco.
7	[\ p {L} && [^ \ p {Lu}]] Qualsiasi lettera tranne una lettera maiuscola.

Di seguito sono riportati vari esempi di Boundary Matcher che utilizzano espressioni regolari in java.

Suor n	Costruisci e abbina
1	^ L'inizio di una riga.
2	$ La fine di una riga.
3	\ b Un confine di parola.
4	\ B Un confine non di parole.
5	\UN L'inizio dell'input.
6	\ G La fine della partita precedente.
7	\ Z La fine dell'input ma per il terminatore finale, se presente.
8	\ z La fine dell'input.

Un quantificatore avido indica al motore di ricerca di cercare l'intera stringa e verificare se corrisponde all'espressione regolare data. Di seguito sono riportati vari esempi di Greedy Quantifiers che utilizzano espressioni regolari in java.

Suor n	Costruisci e abbina
1	X? X, una volta o per niente.
2	X* X, zero o più volte
3	X + X, una o più volte.
4	X {n} X, esattamente n volte.
5	X {n,} X, almeno n volte.
6	X {n, m} X, almeno n ma non più di m volte

Un quantificatore riluttante indica che il motore di ricerca inizia con il pezzo più corto possibile della stringa. Una volta trovata la corrispondenza, il motore continua; altrimenti aggiunge un carattere alla sezione della stringa da controllare e cerca quello, e così via. Questo processo segue fino a quando non trova una corrispondenza o l'intera stringa è stata utilizzata. Di seguito sono riportati vari esempi di quantificatori riluttanti che utilizzano espressioni regolari in java.

Suor n	Costruisci e abbina
1	X?? X, una volta o per niente.
2	X*? X, zero o più volte
3	X +? X, una o più volte.
4	X {n}? X, esattamente n volte.
5	X {n,}? X, almeno n volte.
6	X {n, m}? X, almeno n ma non più di m volte

Un quantificatore possessivo è simile al quantificatore avido. Indica al motore di avviarsi controllando l'intera stringa, è diverso nel senso se non funziona, se il match fallisce e non si guarda indietro. Di seguito sono riportati vari esempi di quantificatori possessivi che utilizzano espressioni regolari in java.

Suor n	Costruisci e abbina
1	X? + X, una volta o per niente.
2	X * + X, zero o più volte
3	X ++ X, una o più volte.
4	X {n} + X, esattamente n volte.
5	X {n,} + X, almeno n volte.
6	X {n, m} + X, almeno n ma non più di m volte

Di seguito sono riportati vari esempi di operatori logici che utilizzano espressioni regolari in java.

Suor n	Costruisci e abbina
1	XY X seguito da Y.
2	X | Y O X o Y.

Stampa