Expressions régulières en Java avec exemples : en pratique

Expressions régulières en Java : de la théorie à la pratique

Les expressions régulières (regex) sont un outil puissant pour rechercher, remplacer et valider du texte. En Java, leur manipulation est implémentée via le package java.util.regex, qui comprend deux classes principales : Pattern (modèle) et Matcher (comparateur). Dans cet article, nous analyserons la syntaxe, les méthodes clés et consoliderons les connaissances avec des exemples de code concrets.

Ce matériel sera utile aussi bien aux débutants découvrant Java qu'aux développeurs expérimentés souhaitant rafraîchir leurs connaissances. Tous les exemples peuvent être exécutés directement dans votre IDE.

1. Bases du travail avec Pattern et Matcher

Tout travail avec regex en Java commence par la compilation du modèle via Pattern.compile(). Ensuite, un objet Matcher est créé, qui applique le modèle à la chaîne.

Considérons un exemple simple : recherche de tous les chiffres dans un texte.

import java.util.regex.Matcher;\nimport java.util.regex.Pattern;\n\npublic class RegexDemo {\n    public static void main(String[] args) {\n        String text = "Java version 21 est sortie en 2023";\n        String regex = "\\\\d+"; // un ou plusieurs chiffres\n\n        Pattern pattern = Pattern.compile(regex);\n        Matcher matcher = pattern.matcher(text);\n\n        while (matcher.find()) {\n            System.out.println("Trouvé : " + matcher.group());\n        }\n    }\n}

Sortie du programme :

Trouvé : 21\nTrouvé : 2023

Notez la double barre oblique \\\\d — en Java, le littéral de chaîne nécessite l'échappement de la barre oblique inverse. Si dans regex vous devez spécifier \\d, dans le code nous écrivons \\\\d.

2. Syntaxe des expressions régulières : métacaractères et quantificateurs

Pour utiliser efficacement les regex, il est important de mémoriser les principaux métacaractères :

\n
• . — n'importe quel caractère (sauf le saut de ligne) ;
\n
• \\\\d — un chiffre (équivalent à [0-9]) ;
\n
• \\\\w — lettre, chiffre ou tiret bas ([a-zA-Z0-9_]) ;
\n
• \\\\s — un caractère d'espacement ;
\n
• ^ — début de la chaîne ;
\n
• $ — fin de la chaîne.
\n

Les quantificateurs contrôlent le nombre de répétitions :

\n
• + — une ou plusieurs fois ;
\n
• * — zéro ou plusieurs fois ;
\n
• ? — zéro ou une fois ;
\n
• {n} — exactement n fois ;
\n
• {n,m} — de n à m fois.
\n

Exemple : trouvons tous les mots composés uniquement de lettres latines, d'une longueur de 3 à 5 caractères.

String text = "Java regex exemple pour débutants";\nString regex = "\\\\b[a-zA-Z]{3,5}\\\\b";\n\nPattern pattern = Pattern.compile(regex);\nMatcher matcher = pattern.matcher(text);\n\nwhile (matcher.find()) {\n    System.out.println(matcher.group());\n}\n// Sortie : Java, regex, pour

La limite de mot \\\\b empêche les correspondances partielles (par exemple, "Java" ne fera pas partie de "JavaScript").

3. Exemples pratiques : validation et extraction de données

Passons aux tâches fréquemment rencontrées dans le développement réel.

3.1. Validation d'une adresse email

Vérification simple : présence du symbole "@" et du domaine.

public static boolean isValidEmail(String email) {\n    String regex = "^[\\\\w.-]+@[\\\\w.-]+\\\\.\\\\w{2,}$";\n    return Pattern.matches(regex, email);\n}\n\npublic static void main(String[] args) {\n    System.out.println(isValidEmail("user@example.com")); // true\n    System.out.println(isValidEmail("email-invalide"));    // false\n}

La méthode Pattern.matches() vérifie automatiquement la chaîne entière (équivalent à matcher.matches()).

3.2. Extraction de numéros de téléphone

Supposons que le texte contienne des numéros au format "+7 (999) 123-45-67".

String text = "Contact : +