Java Academy · Leçon

Groupes de capture

Extrayez les sous-chaînes correspondantes

Groupes de capture est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Que sont les groupes de capture

Les parenthèses ( ) dans une expression régulière créent des groupes de capture. Après une correspondance, vous pouvez extraire séparément le texte de chaque groupe, ce qui est idéal pour analyser des données structurées.

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));
        }
    }
}

Le groupe 0 est la correspondance complète

group(0) (ou group()) renvoie l’intégralité du texte correspondant. Les groupes numérotés commencent à 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));
        }
    }
}

Compter les groupes

groupCount() indique le nombre de groupes de capture dans le pattern, sans compter le groupe 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());
    }
}

Analyser une date

Les groupes de capture permettent de décomposer facilement une valeur formatée en plusieurs parties.

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));
        }
    }
}

Groupes nommés

Nommez un groupe avec (?<name>...) et récupérez-le par son nom. Les patterns deviennent ainsi beaucoup plus lisibles.

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"));
        }
    }
}

Limites des groupes

start(n) et end(n) fournissent l’intervalle d’indices d’un groupe précis dans l’entrée.

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));
        }
    }
}

Groupes sans capture

Utilisez (?:...) pour regrouper des éléments destinés à une alternance ou à des quantificateurs, sans créer de capture numérotée. Les numéros de groupe restent ainsi significatifs.

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));
    }
}

Les groupes facultatifs peuvent être null

Si un groupe est facultatif et n’a pas participé à la correspondance, group(n) renvoie null. Gérez toujours ce cas.

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));
        }
    }
}

Parcourir les correspondances avec des groupes

Combinez find dans une boucle avec l’extraction des groupes pour extraire des jetons structurés d’un texte plus long.

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));
        }
    }
}

Références arrière dans le Pattern

Dans une expression régulière, \1 correspond au même texte qu’un groupe précédent a capturé. Cela permet de détecter une répétition, comme un mot doublé.

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));
    }
}

Capturer dans des enregistrements

Un pattern clair consiste à faire correspondre le texte, à extraire les groupes, puis à construire un petit objet. Ici, nous utilisons un enregistrement.

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);
        }
    }
}

Vérification rapide

Que renvoie group(0) après une correspondance réussie ?

Récapitulatif

Vous avez extrait des sous-chaînes correspondantes :

Les parenthèses créent des groupes numérotés ; group(0) désigne la correspondance complète, et les groupes à partir de 1 sont les captures.
(?<name>...) crée des groupes nommés, lus avec group("name").
(?:...) regroupe des éléments sans effectuer de capture.
Les groupes facultatifs peuvent être null ; \1 fait référence à un groupe précédent.

Questions Fréquemment Posées

La leçon « Groupes de capture » est-elle gratuite ?

Oui — le texte complet de « Groupes de capture » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Groupes de capture » ?

Extrayez les sous-chaînes correspondantes Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Groupes de capture » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Compiler des motifs
Rechercher et faire correspondre
Groupes de capture
Remplacer avec des expressions régulières

← Retour à Java Academy