Expressions régulières en Java avec exemples : Guide complet

Expressions régulières en Java : des bases à l'utilisation avancée

Les expressions régulières (regex) sont un outil puissant pour travailler avec du texte, permettant d'effectuer des recherches, des remplacements et des validations de chaînes selon des motifs complexes. En Java, le support des expressions régulières est implémenté via le package java.util.regex, qui fournit deux classes principales : Pattern (compile le motif) et Matcher(effectue les opérations de recherche/remplacement).

Dans cet article, nous allons voir comment utiliser efficacement les expressions régulières en Java, en commençant par la syntaxe de base et en terminant par des exemples concrets issus de la pratique du développement.

1. Bases de la syntaxe des expressions régulières en Java

Avant de passer au code Java, il est important de maîtriser les principaux métacaractères des expressions régulières :

• . — n'importe quel caractère unique (sauf le saut de ligne)
• \\d — n'importe quel chiffre (0-9)
• \\w — lettre, chiffre ou tiret bas
• \\s — caractère d'espacement (espace, tabulation, nouvelle ligne)
• * — 0 ou plusieurs répétitions du caractère précédent
• + — 1 ou plusieurs répétitions
• ? — 0 ou 1 répétition (rend le caractère optionnel)
• ^ — début de la chaîne
• $ — fin de la chaîne
• [...] — classe de caractères (par exemple, [a-z] — toutes les lettres minuscules)
• (...) — groupe de capture

Important : En Java, les chaînes contenant des expressions régulières nécessitent un double échappement. Par exemple, pour utiliser \\d, on écrit "\\\\d" dans le code. Cela est dû au fait que la barre oblique inverse est d'abord traitée par le compilateur Java, puis transmise au moteur regex.

2. Les classes Pattern et Matcher — le fondement du travail avec regex en Java

Le schéma de base pour travailler avec les expressions régulières en Java comprend trois étapes :

1. Création d'un objet Pattern en compilant la chaîne du motif
2. Création d'un objet Matcher en appelant la méthode matcher() sur la chaîne à vérifier
3. Exécution des opérations — recherche, correspondance, remplacement

Exemple 1 : Vérification de la correspondance de toute la chaîne

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

public class RegexExample {    public static void main(String[] args) {        // Vérification si la chaîne est une adresse email valide        String email = "user@example.com";        String emailPattern = "^[A-Za-z0-9+_.-]+@(.+)$";                Pattern pattern = Pattern.compile(emailPattern);        Matcher matcher = pattern.matcher(email);                if (matcher.matches()) {            System.out.println("Email valide");        } else {            System.out.println("Email invalide");        }    }}

La méthode matches() tente de faire correspondre le motif avec la chaîne entière. Si vous devez vérifier si la chaîne contient une correspondance avec le motif (pas nécessairement entièrement), la méthode find() est utilisée.

Exemple 2 : Recherche de toutes les occurrences d'un motif dans une chaîne

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

public class FindExample {    public static void main(String[] args) {        String text = "Java 8, Java 11, Java 17 — ce sont des versions du langage Java";        String regex = "Java\\\\s+\\\\d+";                Pattern pattern = Pattern.compile(regex);        Matcher matcher = pattern.matcher(text);                while (matcher.find()) {            System.out.println("Trouvé : " + matcher.group() +                                " (position : " + matcher.start() + "-" + matcher.end() + ")");        }    }}

Résultat de l'exécution :

Trouvé : Java 8 (position : 0-6)Trouvé : Java 11 (position : 8-15