Espressioni regolari in Java

Un'espressione regolare è un tipo di modello che può essere applicato al testo (String, in Java). Java fornisce il pacchetto java.util.regex per la corrispondenza delle espressioni regolari. Le espressioni regolari sono molto simili al linguaggio di programmazione Perl e sono molto facili da imparare. Un'espressione regolare corrisponde al testo (parte di esso) oppure no. * Se un'espressione regolare corrisponde a una parte di testo, possiamo trovarla. ** Se l'espressione regolare è composta, possiamo facilmente capire quale parte dell'espressione regolare corrisponde a quale parte del testo.

Primo esempio

L'espressione regolare " [a-z] +" corrisponde a tutte le lettere minuscole nel testo. [a-z]indica qualsiasi carattere da aa zcompreso e +significa "uno o più" caratteri. Supponiamo di fornire la stringa "codice 2 impara tutorial Java". Come farlo in Java Innanzitutto, devi creare un modello:

import java.util.regex.*;
Pattern p = Pattern.compile(“[a-z]+”);

Successivamente devi creare matcheril testo inviando un messaggio sul diagramma:

Matcher m = p.matcher(“code 2 learn java tutorial”);

NOTA: non abbiamo costruttori Pattern, Matcherli creiamo utilizzando metodi di classe Pattern. Pattern Class:L'oggetto classe costituisce una rappresentazione di un'espressione regolare. La classe Pattern non fornisce alcun costruttore pubblico. Per creare un modello, devi prima chiamare uno dei metodi statici pubblici, che poi restituiscono un oggetto della classe Pattern. Questi metodi accettano un'espressione regolare come argomento. Matcher Class:L'oggetto Finder è un motore che interpreta il modello ed esegue operazioni di corrispondenza sulla stringa di input. Come Patternuna classe, Matchernon ha costruttori pubblici. Ottieni un oggetto Matcherchiamando un metodo matchersu un oggetto di classe Pattern. Una volta completati questi passaggi e ora che abbiamo un'istanza della classe Matcher m , possiamo verificare se il modello è stato trovato o meno e, in tal caso, in quale posizione, ecc. m.matches()restituisce vero se il modello corrisponde all'intera stringa, falso altrimenti. m.lookingAt()restituisce vero se il modello corrisponde all'inizio della stringa, falso altrimenti. m.find ()restituisce vero se il modello corrisponde a qualsiasi parte del testo.

Trovare una corrispondenza

Dopo una corrispondenza riuscita, m.start() restituirà l'indice del primo carattere corrispondente e m.end() restituirà l'indice dell'ultimo carattere corrispondente, più uno. Se è stato effettuato un tentativo fallito e non è stata trovata alcuna corrispondenza , m.start()lancerannom.end()IllegalStateException

• Questo è RuntimeExceptioncosì non devi prenderlo.

Può sembrare strano m.end()restituire l'indice dell'ultimo carattere corrispondente più uno, ma è esattamente ciò che la maggior parte dei file String.

• Per esempio,“Now is the time“.substring(m.start(), m.end())

restituirà la stessa stringa. Diamo un'occhiata al codice:

import java.util.regex.*;

public class RegexTest {
    public static void main(String args[]) {
        String pattern = "[a-z]+";
        String text = "code 2 learn java tutorial";
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(text);
        while(m.find()) {
            System.out.print(text.substring(m.start(), m.end()) + "*");
        }
    }
}

Output: code*learn*java*tutorial*

Metodi aggiuntivi

Se c'è una corrispondenza, allora:

• m.replaceFirst(replacement)restituisce una nuova stringa, dove verrà sostituita la prima sottostringa che corrisponde al modelloreplacement
• m.replaceAll(replacement)restituisce una nuova stringa, dove ogni sottostringa che corrisponde al modello verrà sostituita
• m.find(StartIndex)trova la corrispondenza successiva a partire dall'indice specificato
• m.reset()reimposta il modello
• m.reset(NewText)reimposta il finder e gli fornisce un nuovo testo (forse String, StringBuffero CharBuffer)

Sintassi delle espressioni regolari

• ^Corrisponde all'inizio di una riga.
• $Corrisponde alla fine della stringa.
• .Corrisponde a qualsiasi singolo carattere tranne il fine riga. L'uso dell'opzione m consente di abbinare una nuova riga.
• [...]Corrisponde a qualsiasi singolo carattere tra parentesi.
• [^ ...]Corrisponde a qualsiasi singolo carattere non tra parentesi.
• \AInizia l'intera linea.
• \zFine dell'intera riga.
• \ZLa fine dell'intera riga tranne il terminatore di riga finale.
• re*Corrisponde a 0 o più occorrenze dell'espressione precedente.
• re+Una o più corrispondenze dell'espressione precedente.
• re?Corrisponde a 0 o 1 alla posizione dell'espressione precedente.
• re{n}Corrisponde esattamente a N Il numero di occorrenze dell'espressione precedente.
• re{n,}Corrisponde a N o più occorrenze dell'espressione precedente.
• re{n, m}Corrisponde ad almeno n e al massimo m occorrenze dell'espressione precedente.
• a|bCorrisponde a o b.
• (re)Un gruppo di espressioni regolari e il ricordo del testo trovato.
• (?: re)Gruppi di espressioni regolari che non ricordano il testo trovato.
• (?> re)Corrisponde a un modello indipendente senza ritorni.
• \wCorrisponde a lettere e numeri [a-zA-Z_0-9].
• \WQueste non sono lettere o numeri.
• \sCorrisponde agli spazi. Equivalente a [\t\n\r\f].
• \SNon caratteri di spazi bianchi.
• \dCorrisponde ai numeri. Equivalente a [0-9].
• \DNon corrisponde ai numeri.
• \GCorrisponde al punto dell'ultima partita.
• \nCorrisponde alla nuova riga.
• \bCorrisponde al confine di una parola.
• \BCorrispondenze non sul confine di una parola.
• \n, \t, etc.Caratteri di nuova riga, ritorno a capo, tabulazione, ecc.
• \QCita tutti i caratteri prima di \E.
• \ELa citazione iniziata con \Q termina.