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

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Expressions Régulières en Java avec Exemples

Les expressions régulières (regex) sont un outil puissant pour rechercher, extraire et remplacer du texte en fonction d'un modèle. En Java, le travail avec les expressions régulières est implémenté via le package java.util.regex, qui comprend deux classes principales : Pattern et Matcher. Dans cet article, nous aborderons la syntaxe des expressions régulières, les méthodes pour les utiliser, et fournirons des exemples pratiques en Java.

1. Bases de la Syntaxe des Expressions Régulières

Une expression régulière définit un modèle pour rechercher des chaînes de caractères. Voici les constructions de base :

. — n'importe quel caractère (sauf saut de ligne).
\\d — un chiffre (0-9).
\\w — une lettre, un chiffre ou un tiret bas (latin).
\\s — un caractère d'espacement (espace, tabulation, saut de ligne).
[abc] — un des caractères a, b ou c.
[^abc] — tout caractère sauf a, b, c.
* — zéro ou plusieurs répétitions.
+ — une ou plusieurs répétitions.
? — zéro ou une répétition.
{n,m} — de n à m répétitions.
^ — début de la chaîne.
$ — fin de la chaîne.
| — OU logique.
() — groupe de capture.

Échappement en Java : dans les littéraux de chaîne Java, l'antislash \\ est un caractère d'échappement. Pour passer, par exemple, \\d dans une regex, vous devez écrire "\\\\d". Pour un point — "\\\\.".

2. Classes Pattern et Matcher

Le travail avec les expressions régulières en Java commence par la compilation du modèle :

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

public class RegexExample {    public static void main(String[] args) {        // Compiler le modèle        Pattern pattern = Pattern.compile("\\\\d+");        // Créer un Matcher pour la chaîne        Matcher matcher = pattern.matcher("Prix : 150 roubles, réduction 20%");                // Trouver toutes les correspondances        while (matcher.find()) {            System.out.println("Trouvé : " + matcher.group());        }    }}

Sortie :

Trouvé : 150Trouvé : 20

Principales méthodes de Matcher :

find() — recherche la correspondance suivante (peut être appelée plusieurs fois).
matches() — vérifie si toute la chaîne correspond au modèle (nécessite une correspondance complète).
lookingAt() — vérifie si la chaîne commence par le modèle.
group() — retourne la sous-chaîne trouvée (ou un groupe spécifique).
groupCount() — le nombre de groupes de capture.

3. Exemples Pratiques

3.1. Validation d'Adresse Email

Vérifions si une chaîne est un email valide (version simplifiée) :

public class EmailValidator {    public static boolean isValidEmail(String email) {        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$";        Pattern pattern = Pattern.compile(regex);        Matcher matcher = pattern.matcher(email);        return matcher.matches();    }

    public static void main(String[] args) {        System.out.println(isValidEmail("test@exemple.com")); // true        System.out.println(isValidEmail("email-invalide"));    // false    }}

Explication du modèle :

^[a-zA-Z0-9._%+-]+ — partie locale (lettres, chiffres, points, tirets bas, etc.).
@ — le symbole @.
[a-zA-Z0-9.-]+ — domaine (lettres, chiffres, points, traits d'union).
\\\\.[a-zA-Z]{2,}$ — point et domaine de premier niveau (au moins 2 caractères).