Expressions régulières en Java avec exemples : pour débutants

Expressions régulières en Java : guide complet pour débutants

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte selon un modèle. En Java, le travail avec les expressions régulières est implémenté via le package java.util.regex. Dans cet article, nous allons aborder les bases des expressions régulières en Java, apprendre à utiliser les classes Pattern et Matcher, et examiner des exemples pratiques.

1. Classes principales pour travailler avec regex en Java

En Java, deux classes principales sont utilisées pour travailler avec les expressions régulières :

\n
• Pattern — représente une expression régulière compilée.
\n
• Matcher — effectue des opérations de recherche et de correspondance avec le texte.
\n

Il existe également une méthode pratique String.matches(), qui permet de vérifier rapidement si une chaîne correspond à un modèle, mais elle est moins flexible.

Exemple 1 : Correspondance simple

import java.util.regex.*;\n\npublic class RegexExample1 {\n    public static void main(String[] args) {\n        String text = "Bonjour, le monde ! Java est le meilleur langage.";\n        String pattern = "Java";\n\n        Pattern p = Pattern.compile(pattern);\n        Matcher m = p.matcher(text);\n\n        if (m.find()) {\n            System.out.println("Mot trouvé : " + m.group());\n        } else {\n            System.out.println("Aucune correspondance");\n        }\n    }\n}

Sortie : Mot trouvé : Java

2. Métacaractères et classes de caractères

Les expressions régulières utilisent des caractères spéciaux (métacaractères) pour décrire des modèles :

\n
• . — n'importe quel caractère (sauf saut de ligne)
\n
• \\d — chiffre [0-9]
\n
• \\D — non chiffre
\n
• \\w — lettre, chiffre ou souligné [a-zA-Z0-9_]
\n
• \\W — non mot
\n
• \\s — caractère d'espacement
\n
• \\S — non espacement
\n
• [abc] — un des caractères a, b ou c
\n
• [^abc] — tout caractère sauf a, b, c
\n

Exemple 2 : Recherche de chiffres dans un texte

import java.util.regex.*;\n\npublic class RegexExample2 {\n    public static void main(String[] args) {\n        String text = "Mon numéro : 123-456-7890";\n        String pattern = "\\\\d+"; // un ou plusieurs chiffres\n\n        Pattern p = Pattern.compile(pattern);\n        Matcher m = p.matcher(text);\n\n        while (m.find()) {\n            System.out.println("Nombre trouvé : " + m.group());\n        }\n    }\n}

Sortie :

Nombre trouvé : 123\nNombre trouvé : 456\nNombre trouvé : 7890

3. Quantificateurs et limites

Les quantificateurs indiquent combien de fois un élément du modèle doit se répéter :

\n
• * — 0 fois ou plus
\n
• + — 1 fois ou plus
\n
• ? — 0 ou 1 fois
\n
• {n} — exactement n fois
\n
• {n,} — n fois ou plus
\n
• {n,m} — de n à m fois
\n

Les limites aident à spécifier où le modèle doit se trouver :

\n
• ^ — début de la chaîne
\n
• $ — fin de la chaîne
\n
• \\b — limite de mot
\n

Exemple 3 : Validation d'une adresse email

import java.util.regex.*;\n\npublic class RegexExample3 {\n    public static void main(String[] args) {\n        String email = "user@example.com";\n        String pattern = "^[\\\\w.-]+@[\\\\w.-]+\\\\.\\\\w{2,}$";\n\n        boolean isValid = Pattern.matches(pattern, email);\n        System.out.println("Email valide : " + isValid);\n    }\n}

Sortie : Email valide : true

4. Groupes de capture et remplacement de texte

Les groupes de capture permettent d'extraire des parties