Les expressions régulières avec l'API Regex de Java

Les expressions régulières (dites aussi « expressions rationnelles ») sont issues des recherches en mathématiques dans le domaine des automates. Les abréviations reconnues sont « regexp » et « regex ».

Une regex s'apparente à une expression mathématique, car on y trouve des opérateurs, des valeurs et des variables. Les regex permettent de se lancer à la recherche de motifs décrits par la combinaison d'opérateurs et de valeurs.

Une utilisation récurrente des regex consiste en la recherche de mots-clés dans des fichiers ou dans une base de données ou encore en la vérification des données saisies par l'utilisateur afin de s'assurer qu'elles respectent un format prédéfini, ou même d'opérer des conversions de format.

Java fournit dans son JDK depuis la version 1.4 une API standard permettant la manipulation d'expressions régulières.

La documentation (en anglais) de cette API se trouve ici : http://java.sun.com/j2se/1.4.2/docs/api/index.html.

L'API doit être importée en début de fichier de définition de classe comme suit :

import java.util.regex.*;

Il existe deux classes et une exception :

• Pattern : représentation compilée d'un motif ;
• Matcher : moteur de recherche d'un motif dans une chaîne de caractères ;
• PatternSyntaxException : exception lancée lorsqu'une erreur apparaît dans la syntaxe des motifs employés.

import java.io.*;
import java.util.regex.*;

public class testRegex {

    private static Pattern pattern;
    private static Matcher matcher;

    public static void main(String args[]) {
        pattern = Pattern.compile("Hugo");
        matcher = pattern.matcher("Hugo Etiévant");
        while(matcher.find()) {
            System.out.println("Trouvé !");
        }
    }
}

Cet exemple recherche le motif « Hugo » dans la chaîne « Hugo Etiévant » et affiche « Trouvé ! » pour chaque occurrence du motif dans la chaîne.

La syntaxe des motifs est très riche :

• chaînes littérales ;
• métacaractères ;
• classes de caractères ;
• quantificateurs ;
• groupes de capture ;
• frontières de recherche.

La syntaxe la plus aisée consiste à rechercher une simple chaîne de caractères au sein d'une autre.

Exemple :
Motif : « simple chaîne de caractères »
Chaîne à traiter : « autre simple chaîne de caractères »
Résultat trouvé : « simple chaîne de caractères »

L'étape suivante dans la complexité consiste à ajouter des symboles particuliers dont la signification est qu'ils remplacent d'autres caractères. Un peu comme la lettre blanche au Scrabble qui représente n'importe quelle lettre.

Sauf qu'ici un grand nombre de symboles existent, ils peuvent être combinés entre eux et donner des expressions complexes.

Exemple :
Motif : « voiture. »
Chaîne à traiter : « les voitures »
Résultat trouvé : « voitures »
Le caractère spécial . remplace n'importe quel caractère.

Voici la liste des métacaractères :

Une classe de caractères est un ensemble de caractères. Il existe des classes prédéfinies par l'API, mais d'autres ensembles peuvent être construits par le programmeur.

Voici la liste des classes prédéfinies :

Attention : le caractère \ est un caractère spécial, il doit être déspécialisé lorsqu'un alias de classe ou tout autre mot-clé des regex l'utilise. Il est déspécialisé lorsqu'il est doublé \\.

Exemples :

Motif  « \d »
Chaîne à traiter : « j'ai 2 voitures »
Résultat trouvé : « 2 »

Motif : « \W »
Chaîne à traiter : « j'ai 2 voitures »
Résultats trouvés : « ' », «  », «  » (l'apostrophe et les deux espaces)

Voici les règles de constructions des classes personnalisées :

Exemples :

Un quantificateur permet de spécifier le nombre d'occurrences d'un sous-motif du motif. En voici la liste :

Il existe trois classes de quantificateurs :

• les avides (greedy) : lecture de toute la chaîne d'entrée avant de rechercher des occurrences en partant de la fin dans le but de trouver le maximum d'occurrences ;
• les réticents (reluctant) : lecture de la chaîne d'entrée caractère par caractère à la recherche des occurrences ;
• les possessifs (possessive) : lecture de toute la chaîne d'entrée avant de chercher une occurrence.

Certains quantificateurs rendent satisfaisantes des chaînes qui ne comportent pas la chaîne du motif. Par exemple le motif « a* » correspond à trouver zéro fois ou plus la lettre a. Parmi les résultats de la recherche, une chaîne vide "" apparaîtra, car vérifiera le motif.

Exemples :

Les parenthèses utilisées dans les regex permettent de créer des groupes de sous-motifs.

Par exemple, le motif « (a((bc)(d))) » définit 4 groupes : « (a((bc)(d))) », « ((bc)(d)) », « (bc) » et « (d) ». Ils sont numérotés de gauche à droite selon l'ordre de leur parenthèse ouvrante. Le groupe 0 contient toujours l'expression entière même si aucun groupe n'est défini.

Lors de l'exécution de la regex par le moteur Matcher sur une chaîne, les sous-chaînes vérifiant les sous-motifs définis par chacun des groupes seront capturées, c'est-à-dire conservées en mémoire et pourront être réutilisées.

Exemple :

Motif : « (a((b)(c))) »

• groupe 0 : (a((b)(c))) ;
• groupe 1 : (a((b)(c)))
• groupe 2 : ((b)(c))
• groupe 3 : (b)
• groupe 4 : (c)

Chaîne à traiter : « abc »

Résultats trouvés :

• groupe 0 : « abc » ;
• groupe 1 : « abc » ;
• groupe 2 : « bc » ;
• groupe 3 : « b » ;
• groupe 4 : « c »

Après application de la regex sur une chaîne, il est possible de connaître le nombre de sous-chaînes capturées avec la méthode groupCount() de l'objet Matcher.

La méthode group(int group) retourne la sous-chaîne capturée par le groupe n°group.

X-A. Exemple A▲

// compilation de la regex
Pattern p = Pattern.compile("(a((b)(c)))");
// création d'un moteur de recherche
Matcher m = p.matcher("abc");
// lancement de la recherche de toutes les occurrences
boolean b = m.matches();
// si recherche fructueuse
if(b) {
    // pour chaque groupe
    for(int i=0; i <= m.groupCount(); i++) {
        // affichage de la sous-chaîne capturée
        System.out.println("Groupe " + i + " : " + m.group(i));
    }
}

Groupe 0 : abc
Groupe 1 : abc
Groupe 2 : bc
Groupe 3 : b
Groupe 4 : c

X-B. Exemple B▲

// compilation de laregex
Pattern p = Pattern.compile("(a((b)(c)))");
// création d'un moteur de recherche
Matcher m = p.matcher("abc");
// lancement de la recherche de toutes les occurrences successives
while(m.find()) {
    // affichage de la sous-chaîne capturée,
    // de l'index de début dans la chaîne originale
    // et de l'index de fin
    System.out.println("Le texte \"" + m.group() +
            "\" débute à " + m.start() + " et termine à " + m.end());
}

Le texte "abc" débute à 0 et termine à 3

X-C. Méthodes▲

X-D. Références▲

Il est désormais intéressant de forcer l'emplacement des motifs recherchés : en début de ligne, en fin de mot… Les « spécificateurs de frontière » sont résumés dans le tableau suivant :

Exemples :

La méthode de compilation d'expression régulière prend pour paramètres la regex et un paramètre optionnel flags.
Syntaxe : static Pattern compile(String regex, int flags)

Liste des options :

Ces options existent sous la forme de constantes de type entier (static int) dans la classe Pattern.

Plusieurs options peuvent être combinées grâce à l'opérateur OU binaire : |.

Exemples :

Pattern p = Pattern.compile("^[abc]$",
Pattern.CASE_INSENSITIVE);

Pattern p = Pattern.compile("^[abc]$",
    Pattern.MULTILINE | Pattern.UNIX_LINES);

Nous avons vu comment passer ces options en paramètre à la méthode compile(). Il est également possible d'écrire ces options directement dans le motif de la regex. Elles doivent être placées en tout début.

Exemple :

Motif : « (?i)foobar » Chaîne à traiter : « FooBar, foobar, FOOBAR » Résultats trouvés : « FooBar », « foobar », « FOOBAR »

XIV-A. Matcher▲

boolean matches();

// compilation de la regex
Pattern p = Pattern.compile("(a((b)(c)))");
// création d'un moteur de recherche
Matcher m = p.matcher("abc");
// lancement de la recherche de toutes les occurrences
boolean b = m.matches();

XIV-B. Pattern▲

static boolean matches(String regex, CharSequence input)

// lancement de la recherche de toutes les occurrences
boolean b = Pattern.matches("(a((b)(c)))", "abc");

La méthode split() de la classe Pattern permet de scinder une chaîne en plusieurs sous-chaînes grâce à un délimiteur défini par un motif. Le paramètre optionnel limit permet de fixer le nombre maximum de sous-chaînes générées. Elle retourne un tableau de String.

Syntaxe :

String[] split(CharSequence input [, int limit])

Exemple :

// compilation de la regex
Pattern p = Pattern.compile(":");
// séparation en sous-chaînes
String[] items = p.split("un:deux:trois");

XV-A. Exemple▲

// compilation de la regex
Pattern p = Pattern.compile("\\W");
// séparation en sous-chaînes
String[] items = p.split("J'aime le chocolat.", 10);
// parcours du tableau des sous-chaînes
for(int i=0; i<items.length; i++) {
System.out.println(items[i]);
}

J
aime
le
chocolat

La classe Matcher offre des fonctions qui permettent de remplacer les occurrences d'un motif par une autre chaîne.

Syntaxe :

String replaceFirst(String replacement)
String replaceAll(String replacement)

Ces méthodes remplacent respectivement la première occurrence et toutes les occurrences du motif de la regex compilée associée au moteur.

XVI-A. Exemple▲

// compilation de la regex avec le motif : "thé"
Pattern p = Pattern.compile("thé");
// création du moteur associé à la regex sur la chaîne "J'aime le thé."
Matcher m = p.matcher("J'aime le thé.");
// remplacement de toutes les occurrences de "thé" par "chocolat"
Strings = m.replaceAll("chocolat");

05 août 2004 : corrections mineures

22 mai 2004 : première publication (36 diapos)

20 mai 2004 : création du document (20 diapos)

Agissez sur la qualité de ce document en envoyant vos critiques et suggestions à l'auteur.

Pour toute question technique, se reporter au forum Java de Developpez.com.

Reproduction autorisée uniquement pour un usage non commercial.

Cet article a été mis au gabarit de developpez.com. Voici le lien vers le PDF d'origine : regex.pdf.

Le gabarisateur remercie Claude LELOUP pour sa correction orthographique.