Java Academy · Lezione

Gruppi di cattura

Estrarre le sottostringhe corrispondenti

Gruppi di cattura è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Che cosa sono i gruppi di cattura

Le parentesi ( ) in una regex creano gruppi di cattura. Dopo una corrispondenza può estrarre separatamente il testo di ogni gruppo, una soluzione ideale per analizzare dati strutturati.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)-(\\d+)").matcher("42-99");
        if (m.find()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

Il gruppo 0 è l'intera corrispondenza

group(0) (o group()) restituisce l'intero testo corrispondente. I gruppi numerati iniziano da 1.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)px").matcher("width: 24px");
        if (m.find()) {
            System.out.println(m.group(0));
            System.out.println(m.group(1));
        }
    }
}

Contare i gruppi

groupCount() restituisce il numero di gruppi di cattura presenti nel pattern, senza contare il gruppo 0.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.find()) System.out.println(m.groupCount());
    }
}

Analizzare una data

I gruppi di cattura rendono semplice suddividere un valore formattato nelle sue parti.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.matches()) {
            System.out.println("year=" + m.group(1));
            System.out.println("month=" + m.group(2));
            System.out.println("day=" + m.group(3));
        }
    }
}

Gruppi denominati

Assegni un nome a un gruppo con (?<name>...) e lo recuperi tramite il nome. In questo modo i pattern risultano molto più leggibili.

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

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(?<user>\\w+)@(?<host>\\w+\\.\\w+)");
        Matcher m = p.matcher("alice@example.com");
        if (m.find()) {
            System.out.println(m.group("user"));
            System.out.println(m.group("host"));
        }
    }
}

Limiti dei gruppi

start(n) ed end(n) indicano l'intervallo di indici di uno specifico gruppo all'interno dell'input.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)").matcher("abc123");
        if (m.find()) {
            System.out.println(m.start(1) + " to " + m.end(1));
        }
    }
}

Gruppi non catturanti

Usi (?:...) per raggruppare elementi destinati ad alternanze o quantificatori senza creare una cattura numerata. In questo modo i numeri dei gruppi restano significativi.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(?:Mr|Ms)\\.? (\\w+)").matcher("Ms. Smith");
        if (m.find()) System.out.println(m.group(1));
    }
}

I gruppi opzionali possono essere null

Se un gruppo è opzionale e non ha partecipato alla corrispondenza, group(n) restituisce null. Gestisca sempre questo caso.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)(px)?").matcher("50");
        if (m.matches()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

Iterare sulle corrispondenze con i gruppi

Combini find in un ciclo con l'estrazione dei gruppi per recuperare token strutturati da un testo più ampio.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\w+)=(\\d+)").matcher("a=1 b=2 c=3");
        while (m.find()) {
            System.out.println(m.group(1) + " -> " + m.group(2));
        }
    }
}

Riferimenti all'indietro nel pattern

All'interno di una regex, \1 corrisponde allo stesso testo catturato in precedenza da un gruppo. Questo consente di rilevare le ripetizioni, ad esempio una parola duplicata.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\w+) \\1").matcher("the the cat");
        System.out.println(m.find());
        System.out.println(m.group(1));
    }
}

Catturare i dati nei record

Un pattern efficace segue questo schema: trovare la corrispondenza, estrarre i gruppi e creare un piccolo oggetto. Qui usiamo un record.

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

public class Main {
    record Point(int x, int y) {}

    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\((\\d+),(\\d+)\\)").matcher("(3,7)");
        if (m.matches()) {
            Point p = new Point(Integer.parseInt(m.group(1)), Integer.parseInt(m.group(2)));
            System.out.println(p);
        }
    }
}

Verifica rapida

Che cosa restituisce group(0) dopo una corrispondenza riuscita?

Riepilogo

Ha estratto sottostringhe corrispondenti:

Le parentesi creano gruppi numerati; group(0) rappresenta l'intera corrispondenza, mentre i gruppi da 1 in poi sono catture.
(?<name>...) crea gruppi denominati, letti tramite group("name").
(?:...) raggruppa senza catturare.
I gruppi opzionali possono essere null; \1 fa riferimento all'indietro a un gruppo precedente.

Domande Frequenti

La lezione «Gruppi di cattura» è gratuita?

Sì — il testo completo di «Gruppi di cattura» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Gruppi di cattura»?

Estrarre le sottostringhe corrispondenti Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Gruppi di cattura»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Compilazione dei pattern
Ricerca e corrispondenza
Gruppi di cattura
Sostituzione con le espressioni regolari

← Torna a Java Academy