Expressions régulières en Java — java.util.regex

Expressions régulières en Java — java.util.regex

  Prérequis

Maîtriser la classe String et ses méthodes de recherche. Comprendre les notions de pattern, de compilation et de correspondance. Avoir des bases sur la gestion des exceptions.

  Objectifs

Comprendre les trois classes du package java.util.regex. Construire des expressions régulières avec les métacaractères Java. Utiliser Pattern, Matcher et leurs méthodes pour rechercher, valider et remplacer du texte.

  Un peu d'histoire

Les expressions régulières (regex) ont été inventées par le mathématicien Stephen Kleene dans les années 1950. Elles ont été popularisées par les outils Unix (grep, sed, awk) et sont aujourd'hui disponibles dans tous les langages modernes. Java les intègre nativement via le package java.util.regex depuis Java 1.4.

1. Architecture du package java.util.regex

Le package java.util.regex repose sur trois classes principales :

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

String regex  = "motif";
String texte  = "texte à analyser";

Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(texte);

if (matcher.find()) {
    System.out.println("Trouvé !");
}

2. Syntaxe des expressions régulières

2.1 Ancres et positions

2.2 Classes de caractères

2.3 Quantificateurs

2.4 Groupes et alternance

2.5 Échappement des métacaractères

String regex = "\\d+";     // regex : \d+  (un ou plusieurs chiffres)
String regex = "\\bdev\\b"; // regex : \bdev\b (mot entier "dev")
String regex = "\\.com";    // regex : \.com  (point littéral + "com")

3. La classe Pattern

Pattern p1 = Pattern.compile("\\d+");

Pattern p2 = Pattern.compile("^[A-Z]", Pattern.CASE_INSENSITIVE);

Pattern p3 = Pattern.compile(
    "^[a-zA-Z0-9._%+-]+" +
    "@[a-zA-Z0-9.-]+" +
    "\\.[a-zA-Z]{2,}$"
);

boolean valide = p3.matcher("user@example.com").matches();
System.out.println("Email valide : " + valide);

Email valide : true

4. La classe Matcher et ses méthodes

4.1 Méthodes d'étude (recherche)

4.2 Méthodes d'indexation

4.3 Méthodes de remplacement

5. Groupes de capture

  Exemple 1 — Groupes de capture

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

public class TestGroupes {
    public static void main(String[] args) {
        String line    = "www.developpement123.com";
        String pattern = "(.*)([0-9]+)(.*)";

        Pattern r = Pattern.compile(pattern);
        Matcher m = r.matcher(line);

        System.out.println("Nombre de groupes : " + m.groupCount());
        if (m.find()) {
            System.out.println("Groupe 0 (tout) : " + m.group(0));
            System.out.println("Groupe 1 (.*)   : " + m.group(1));
            System.out.println("Groupe 2 ([0-9]+): " + m.group(2));
            System.out.println("Groupe 3 (.*)   : " + m.group(3));
        }
    }
}

Nombre de groupes : 3
Groupe 0 (tout)  : www.developpement123.com
Groupe 1 (.*)    : www.developpement12
Groupe 2 ([0-9]+): 3
Groupe 3 (.*)    : .com

6. Exemples pratiques

  Exemple 2 — Trouver toutes les occurrences d'un motif

import java.util.regex.*;

Pattern pattern = Pattern.compile("dev");
Matcher m = pattern.matcher("info-dev : www.developpement-informatique.com");

while (m.find()) {
    System.out.println("Motif trouvé de " + m.start() + " à " + (m.end() - 1));
}

Motif trouvé de 5 à 7
Motif trouvé de 15 à 17

  Exemple 3 — Mots entiers avec \b

Pattern pattern = Pattern.compile("\\bdev\\b");
Matcher m = pattern.matcher("info dev : www.developpement-informatique.com");

int cpt = 0;
while (m.find()) {
    cpt++;
    System.out.println("Mot " + cpt + " : indice " + m.start() + " à " + (m.end() - 1));
}
System.out.println("Total : " + cpt + " occurrence(s)");

Mot 1 : indice 5 à 7
Total : 1 occurrence(s)

  Exemple 4 — matches() vs lookingAt() vs find()

Pattern pattern = Pattern.compile("dev");
Matcher matcher = pattern.matcher("developpement-informatique.com");

System.out.println("find()      : " + matcher.find());
matcher.reset();
System.out.println("lookingAt() : " + matcher.lookingAt());
matcher.reset();
System.out.println("matches()   : " + matcher.matches());

find()      : true  (trouve "dev" n'importe où)
lookingAt() : true  (la chaîne COMMENCE par "dev")
matches()   : false (la chaîne entière n'est PAS "dev")

  Exemple 5 — replaceAll() et replaceFirst()

Pattern pattern = Pattern.compile("dev");
Matcher matcher = pattern.matcher("info-dev, dev-info, dev");

String remplaceAll    = matcher.replaceAll("soft");
System.out.println("replaceAll    : " + remplaceAll);

matcher.reset();
String remplaceFirst  = matcher.replaceFirst("soft");
System.out.println("replaceFirst  : " + remplaceFirst);

replaceAll    : info-soft, soft-info, soft
replaceFirst  : info-soft, dev-info, dev

  Exemple 6 — appendReplacement / appendTail

Pattern pattern = Pattern.compile("dev");
Matcher matcher = pattern.matcher("info-dev, dev-info");

StringBuffer resultat = new StringBuffer();
while (matcher.find()) {
    matcher.appendReplacement(resultat, "soft");
}
matcher.appendTail(resultat);
System.out.println(resultat);

info-soft, soft-info

7. Gestion des erreurs — PatternSyntaxException

import java.util.regex.*;

try {
    Pattern p = Pattern.compile("[chiffre invalide");
} catch (PatternSyntaxException e) {
    System.out.println("Erreur dans le pattern !");
    System.out.println("Description : " + e.getDescription());
    System.out.println("Indice      : " + e.getIndex());
    System.out.println("Pattern     : " + e.getPattern());
}

Erreur dans le pattern !
Description : Unclosed character class
Indice      : 0
Pattern     : [chiffre invalide

8. Patterns de validation courants

  Complément — Regex utiles en pratique

9. Exercice

=== Validation emails ===
mostafa@um6p.ma       : valide
contact@.invalid      : invalide
user.name+tag@site.fr : valide
@nodomain.com         : invalide

=== Extraction de nombres ===
Texte : "Java 21 sort en 2023 avec 15 nouvelles fonctionnalités"
Nombres trouvés : 21, 2023, 15

=== Nettoyage d'espaces ===
Avant : "Java   est   un   langage"
Après : "Java est un langage"

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

public class ValidateurRegex {

    static final Pattern EMAIL_PATTERN =
        Pattern.compile("^[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$");

    static final Pattern NOMBRE_PATTERN =
        Pattern.compile("\\d+");

    static final Pattern ESPACES_PATTERN =
        Pattern.compile("\\s+");

    static boolean validerEmail(String email) {
        return EMAIL_PATTERN.matcher(email).matches();
    }

    static void extraireNombres(String texte) {
        System.out.println("Texte : \"" + texte + "\"");
        Matcher m = NOMBRE_PATTERN.matcher(texte);
        StringBuilder nombres = new StringBuilder("Nombres trouvés : ");
        boolean premier = true;
        while (m.find()) {
            if (!premier) nombres.append(", ");
            nombres.append(m.group());
            premier = false;
        }
        System.out.println(nombres);
    }

    static String nettoyerEspaces(String texte) {
        return ESPACES_PATTERN.matcher(texte).replaceAll(" ");
    }

    public static void main(String[] args) {

        System.out.println("=== Validation emails ===");
        String[] emails = {
            "mostafa@um6p.ma",
            "contact@.invalid",
            "user.name+tag@site.fr",
            "@nodomain.com"
        };
        for (String email : emails) {
            System.out.printf("%-25s : %s%n",
                email,
                validerEmail(email) ? "valide" : "invalide");
        }

        System.out.println("\n=== Extraction de nombres ===");
        extraireNombres("Java 21 sort en 2023 avec 15 nouvelles fonctionnalités");

        System.out.println("\n=== Nettoyage d'espaces ===");
        String brut = "Java   est   un   langage";
        System.out.println("Avant : \"" + brut + "\"");
        System.out.println("Après : \"" + nettoyerEspaces(brut) + "\"");
    }
}

=== Validation emails ===
mostafa@um6p.ma           : valide
contact@.invalid          : invalide
user.name+tag@site.fr     : valide
@nodomain.com             : invalide

=== Extraction de nombres ===
Texte : "Java 21 sort en 2023 avec 15 nouvelles fonctionnalités"
Nombres trouvés : 21, 2023, 15

=== Nettoyage d'espaces ===
Avant : "Java   est   un   langage"
Après : "Java est un langage"

  L'essentiel en bref

Le package java.util.regex expose trois classes : Pattern (motif compilé créé via Pattern.compile()), Matcher (moteur de correspondance créé via pattern.matcher(texte)), et PatternSyntaxException (erreur de syntaxe dans le pattern). Les méthodes clés du Matcher sont find() pour rechercher la prochaine occurrence, matches() pour valider toute la chaîne, lookingAt() pour vérifier le début, replaceAll() et replaceFirst() pour substituer du texte, et group(n) pour extraire les groupes capturants. En Java, chaque \ regex s'écrit \\ dans une chaîne Java — toujours doubler les barres obliques inverses. Compilez vos Pattern une seule fois (constante static final) si vous les réutilisez fréquemment.