Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Pattern.compile — compilare un’espressione regolare

Compila un’espressione regolare in un oggetto `Pattern` e riutilizza lo stesso modello per verificare più stringhe di input.

Versione: Java SE 21

Sintassi

import java.util.regex.Pattern;

// Static method signatures in java.util.regex.Pattern:
public static Pattern compile(String regex)
public static Pattern compile(String regex, int flags)

In Java SE 21, Pattern.compile è un metodo statico della classe java.util.regex.Pattern. Riceve un’espressione regolare come String e restituisce un oggetto Pattern compilato. La compilazione, da sola, non verifica alcun testo di input.

Pattern.compile(regex) non accetta un argomento separato per i flag, ma l’espressione può contenere un flag incorporato, come (?i). Il sovraccarico Pattern.compile(regex, flags) accetta una maschera di bit di tipo int. Usa | per combinare i flag, ad esempio Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE per ignorare le differenze tra maiuscole e minuscole secondo le regole Unicode.

Una sintassi non valida provoca l’eccezione non controllata PatternSyntaxException durante la compilazione del modello. Il sovraccarico con i flag genera IllegalArgumentException se nella maschera sono impostati bit che non corrispondono a flag definiti.

pattern.matcher(input) crea un Matcher per l’input dato. Il metodo matches() verifica l’intera regione corrente, che per impostazione predefinita comprende tutto l’input. Per cercare una sottostringa corrispondente, usa invece find(). Se devi ripetere il controllo, riutilizza il Pattern immutabile, che puoi condividere tra thread. Un Matcher conserva lo stato della ricerca e non è sicuro usarlo in modo concorrente.

Esempi

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern[] patterns = {
            Pattern.compile("[A-Z]{2}[0-9]{2}"),
            Pattern.compile("[0-9]+"),
            Pattern.compile("[A-Z]+"),
            Pattern.compile("[A-Z0-9]+"),
            Pattern.compile("AB.*")
        };

        System.out.println("Pattern | AB12 | 123");
        for (Pattern pattern : patterns) {
            System.out.println(pattern.pattern() + " | "
                    + pattern.matcher("AB12").matches() + " | "
                    + pattern.matcher("123").matches());
        }
    }
}

Risultato

Pattern | AB12 | 123
[A-Z]{2}[0-9]{2} | true | false
[0-9]+ | false | true
[A-Z]+ | false | false
[A-Z0-9]+ | true | true
AB.* | true | false

Il programma compila cinque modelli senza flag e prova ciascuno con `AB12` e `123`. `[A-Z]+` non corrisponde a `AB12`: le lettere `AB` rispettano il modello, ma `matches()` richiede che corrisponda l’intero input.

Lezioni correlate

  • Java · Lezione 70 · Base · Versione: 2

Fonti