Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Sintassi delle espressioni regolari in Java

Impara a leggere i pattern regex di Java 21 con classi di caratteri, quantificatori, gruppi, ancore, sequenze di escape e flag incorporati.

Versione: Java SE 21

Sintassi

Regex: [A-Z], [^, ], \d, \., (X), (?:X), X?, X*, X+, X{n}, X{n,}, X{n,m}, ^, $, \A, \z, (?i)X, (?i:X)
Lesson pattern: (?i)password=[^, ]+
Java string literal: "\\A([A-Z]{2})-(\\d+)\\z"
Java API (assuming regex has at least one capturing group):
Matcher matcher = Pattern.compile(regex).matcher(input);
boolean wholeRegionMatches = matcher.matches();
matcher.reset();
if (matcher.find()) {
    String firstGroup = matcher.group(1);
}

Pattern.compile(regex), in java.util.regex, compila il pattern e genera PatternSyntaxException se la sintassi non è valida. matcher(input) crea un Matcher: matches() verifica l’intera regione (tutto l’input per impostazione predefinita), mentre find() cerca la successiva sottostringa corrispondente.

Una classe corrisponde a un carattere: [A-Z] riconosce una maiuscola ASCII e \d riconosce per impostazione predefinita una cifra ASCII. I quantificatori si applicano all’elemento o al gruppo precedente: ? indica zero o una volta, * zero o più volte, + una o più volte, {n} esattamente n volte, {n,} almeno n volte e {n,m} da n a m volte incluse. (X) cattura testo; (?:X) raggruppa senza catturare. Dopo una corrispondenza riuscita, group(0) restituisce l’intera corrispondenza e group(1) il testo del primo gruppo di cattura se ha partecipato.

Le ancore indicano posizioni senza consumare caratteri. ^ e $ indicano l’inizio e la fine; (?m) consente loro di corrispondere anche ai limiti delle righe. $ può corrispondere anche prima del terminatore di riga finale. \A e \z indicano l’inizio e la fine esatti dell’input con i limiti di regione predefiniti. L’escape ha due livelli: la regex \. riconosce un punto letterale e nel sorgente Java si scrive "\\d" per passare la regex \d al motore.

In (?i)password=[^, ]+, il flag incorporato (?i) ignora le differenze tra maiuscole e minuscole ASCII da quel punto in poi; (?i:X) limita il flag a X. Un ^ all’inizio della classe la nega: [^, ] esclude solo la virgola e lo spazio normale, non le tabulazioni o le interruzioni di riga. + richiede un valore non vuoto che si ferma alla prima virgola, al primo spazio o alla fine dell’input. Il pattern non controlla il limite sinistro del nome del campo e quindi non è un modo affidabile per oscurare segreti.

Esempi

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

public class RegexPatternsDemo {
    public static void main(String[] args) {
        Pattern id = Pattern.compile("\\A([A-Z]{2})-(\\d+)\\z");
        Matcher matcher = id.matcher("AB-204");
        if (matcher.matches()) {
            System.out.println("ID: " + matcher.group(1) + "/" + matcher.group(2));
        }

        Pattern field = Pattern.compile("(?i)password=[^, ]+");
        System.out.println("Field found: " + field.matcher("user=demo, PASSWORD=sample, role=test").find());
        System.out.println("Empty field found: " + field.matcher("user=demo, PASSWORD=, role=test").find());
    }
}

Risultato

ID: AB/204
Field found: true
Empty field found: false

Il programma legge due catture da `AB-204`, poi usa `find()` su due testi di esempio per verificare se `PASSWORD=` è seguito da un valore non vuoto. Non stampa il valore del campo.

Lezioni correlate

  • Java · Lezione 55 · Avanzato · Versione: 2
  • Java · Lezione 70 · Base · Versione: 2

Fonti