Introduction aux expressions régulières Java

Une expression régulière (regex) est un patron compact qui décrit un ensemble de chaînes. En Java, le package java.util.regex transforme ces patrons en un petit moteur de correspondance rapide que vous pouvez appliquer à n'importe quel texte — pour valider des entrées, rechercher des sous-chaînes, extraire des champs ou réécrire du contenu. Ce chapitre présente les éléments de base avant que vous ne commenciez à écrire vos propres patrons.

Ce qu'est une expression régulière

Une regex n'est qu'une chaîne écrite dans une syntaxe spéciale, mais Java ne l'interprète pas caractère par caractère à chaque fois. À la place, vous compilez le patron une seule fois en un objet Pattern, puis vous l'appliquez à une entrée via un Matcher. La forme compilée est une machine à états efficace, donc réutiliser un Pattern sur de nombreuses entrées est bien moins coûteux que de le recompiler.

Les patrons décrivent une structure : un littéral comme cat correspond exactement à ces lettres, tandis que les métacaractères décrivent des formes — \d est n'importe quel chiffre, + signifie « un ou plus », . signifie « n'importe quel caractère ». Combinez-les et vous pouvez décrire des numéros de téléphone, des e-mails ou des lignes de journal en une seule ligne de code.

import java.util.regex.Pattern;

public class FirstPattern {
    public static void main(String[] args) {
        // Compile the pattern once; reuse the result.
        Pattern digits = Pattern.compile("\\d+");
        System.out.println(digits.matcher("abc123").find()); // true
        System.out.println(digits.matcher("hello").find());  // false
    }
}

Notez le double antislash : \d en regex doit être écrit \\d dans un littéral de chaîne Java, car le compilateur Java consomme un antislash en premier.

Pattern et Matcher

Deux classes font presque tout le travail. Pattern est le modèle compilé, réutilisable et thread-safe. Matcher est le moteur avec état qui exécute ce modèle sur une entrée spécifique — il suit votre position dans le texte, quels groupes ont capturé, et où s'est arrêtée la dernière correspondance. Créez un nouveau Matcher par entrée ; ne le partagez jamais entre threads.

Type	Rôle
`Pattern`	Le patron compilé. Immuable, thread-safe, réutilisable.
`Matcher`	Applique un `Pattern` à une entrée. Conserve l'état de correspondance.
`Pattern.compile(regex)`	Construit un `Pattern` à partir d'une chaîne regex.
`pattern.matcher(input)`	Retourne un `Matcher` lié à cette entrée.
`String.matches(regex)`	Aide ponctuelle qui compile et effectue une correspondance complète en un seul appel.

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

public class PatternAndMatcher {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\w+@\\w+\\.\\w+");
        Matcher m = p.matcher("ping me at [email protected] please");
        if (m.find()) {
            System.out.println("Found email: " + m.group());
        }
    }
}

find() vs matches()

L'erreur la plus courante chez les débutants est de confondre les deux façons d'exécuter un patron. matches() exige que l'intégralité de l'entrée corresponde au patron du début à la fin. find() recherche n'importe quelle sous-chaîne correspondante, et peut être appelé de façon répétée pour parcourir chaque occurrence. lookingAt() se situe entre les deux : il ancre au début mais n'exige pas de correspondance jusqu'à la fin.

Méthode	Ancré au début ?	Doit correspondre jusqu'à la fin ?	Répétable ?
`matches()`	oui	oui	non
`lookingAt()`	oui	non	non
`find()`	non	non	oui

import java.util.regex.Pattern;

public class FindVsMatches {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("42").matches());        // true  (whole input)
        System.out.println(p.matcher("age 42").matches());    // false (extra text)
        System.out.println(p.matcher("age 42").find());       // true  (substring)
        System.out.println(p.matcher("age 42").lookingAt());  // false (no digit at start)
    }
}

Syntaxe courante sur laquelle vous vous appuyez

La plupart des patrons réels sont assemblés à partir d'un petit vocabulaire de blocs de construction : classes de caractères, raccourcis prédéfinis, quantificateurs et ancres. Apprendre ces éléments vous donne une grande partie du chemin. Chaque construction a un chapitre dédié — consultez Syntaxe regex, classes de caractères et quantificateurs pour tous les détails.

Construction	Signification	Exemple
`.`	N'importe quel caractère unique (sauf saut de ligne)	`a.c` correspond à `abc`, `axc`
`\d` `\w` `\s`	Chiffre, caractère de mot, espace	`\d\d` correspond à `42`
`[abc]`	L'un quelconque de a, b, c	`[aeiou]` correspond à une voyelle
`[^abc]`	N'importe quel caractère sauf a, b, c	`[^0-9]` correspond à un non-chiffre
`*` `+` `?`	Zéro+, un+, zéro-ou-un	`ab+` correspond à `ab`, `abb`
`{n}` `{n,m}`	Exactement n, entre n et m	`\d{3}` correspond à `555`
`^` `$`	Début, fin de l'entrée/ligne	`^Hi` correspond à un `Hi` en début
`(...)`	Groupe capturant	`(\d{4})` capture quatre chiffres

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

public class GroupsExample {
    public static void main(String[] args) {
        // Two capturing groups: year and month.
        Pattern date = Pattern.compile("(\\d{4})-(\\d{2})");
        Matcher m = date.matcher("Released 2025-11 to users");
        if (m.find()) {
            System.out.println("Full: " + m.group(0)); // 2025-11
            System.out.println("Year: " + m.group(1)); // 2025
            System.out.println("Month: " + m.group(2)); // 11
        }
    }
}

Exemple concret

Le programme ci-dessous compile un patron de numéro de téléphone et exerce toute l'API sur lui : il parcourt chaque correspondance avec find(), lit les groupes capturants et les positions de correspondance, contraste find() avec matches(), et réécrit le texte avec replaceAll(). Exécutez-le pour voir le moteur en action.

java— editable, runs on the server

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

public class RegexBasics {
    public static void main(String[] args) {
        // Compile a pattern once, reuse it many times.
        Pattern phone = Pattern.compile("(\\d{3})-(\\d{4})");
        String text = "Call 555-1234 or 555-9876 today.";

Matcher m = phone.matcher(text);
        int count = 0;
        while (m.find()) {
            count++;
            System.out.println("Match " + count + ": " + m.group());
            System.out.println("  prefix=" + m.group(1) + " line=" + m.group(2));
            System.out.println("  at index " + m.start() + ".." + m.end());
        }
        System.out.println("Total matches: " + count);

// matches() must consume the WHOLE input; find() scans for any part.
        System.out.println("Whole text matches pattern? " + phone.matcher(text).matches());
        System.out.println("Just 555-1234 matches? " + phone.matcher("555-1234").matches());

// A quick test via String.matches uses the same engine.
        System.out.println("abc123 is alnum? " + "abc123".matches("[a-z0-9]+"));

// replaceAll rewrites every match.
        String masked = phone.matcher(text).replaceAll("XXX-XXXX");
        System.out.println("Masked: " + masked);
    }
}

Ce que l'on retient de l'exécution :

find() est appelé en boucle et retourne deux correspondances, donc le même Matcher parcourt le texte une occurrence à la fois jusqu'à ce qu'il retourne false.
group(1) et group(2) retournent les sous-parties entre parenthèses (555 et 1234), tandis que group() sans argument retourne la correspondance entière.
start() et end() indiquent les décalages de caractères de chaque correspondance, ce qui permet de surligner ou de découper le texte d'origine.
matches() sur la phrase complète affiche false car le patron ne couvre pas la chaîne entière, tandis que "555-1234" seul affiche true — preuve que matches() s'applique uniquement à l'entrée complète.
replaceAll("XXX-XXXX") réécrit chaque correspondance en un seul passage, produisant la phrase masquée et montrant comment les patrons pilotent la transformation de texte.

Où aller ensuite

Maintenant que vous connaissez les éléments clés — Pattern, Matcher, et la différence entre find() et matches() — approfondissez avec les chapitres thématiques :

Pattern et Matcher — l'API complète pour compiler et exécuter des patrons.
Syntaxe regex — chaque métacaractère et échappement, expliqués.
Classes de caractères — ensembles, plages et négation.
Quantificateurs — répétition gourmande, réticente et possessive.
Groupes capturants — extraction et référence arrière de sous-parties.
Indicateurs — insensibilité à la casse, multiligne et autres modificateurs.

Pratique

Quelle est la différence essentielle entre Matcher.matches() et Matcher.find() ?

matches() exige que l'entrée entière corresponde, tandis que find() localise n'importe quelle sous-chaîne correspondantematches() est insensible à la casse, tandis que find() est sensible à la cassefind() ne peut être appelé qu'une seule fois, tandis que matches() peut être mis en bouclematches() retourne le texte correspondant, tandis que find() retourne un boolean