Expressions régulières en Java

Expressions régulières en Java
^ indique le début d’une chaîne de caractères.
$ indique la fin d’une chaîne de caractères.
. indique un caractère quelconque.
Exemples
^abc
abc$
abc
^abc$
^.$
Une chaîne commençant par abc
Une chaîne se terminant par abc
Une chaîne contenant abc
La chaîne abc
Une chaîne de 1 caractère quelconque
Regex
c.t
c.t
c.t
^dog$
dog$
cat$
Chaîne
cat
ct
ct
dog
dog cat
dog cat
Correspondance
Vrai
Faux
Vrai
Vrai
Faux
Vrai
Classe de caractères



Une classe de caractères correspond aux caractères contenus dans la classe
[…] un caractère
[^…] tout sauf les caractères
[abc]
[0-9]
[A-Z]
[0-9A-Z]
[a-zAZ]
[^abc]
Le caractère a, b ou c
Un caractère compris entre 0 et 9 inclusivement
Une lettre majuscule
Une lettre majuscule ou un caractère numérique
Une lettre
N’importe quel caractère sauf a, b ou c
Auteur : Eliana de M.P. Coelho
Regex
[0-9]%
[a-z]t
[a-z]t
[a-z]T
[a-zA-Z]!
[a-zA-Z]!
[^bcr]at
[^bcr]at
Chaîne
we are 95% complete
11th
cat
PIT
11!
Stop!
bat
hat
Correspondance
Vrai
Faux
Vrai
Faux
Faux
Vrai
Faux
Vrai
Quantificateurs
Les quantificateurs permettent de spécifier le nombre d’occurrences d’un élément d’une
expression régulière.
?
+
*
{n,m}
{n,}
{n}
{,n}
Regex
a?
a*
a+
a?
a*
a+
0 ou 1 fois
Une fois ou plus
Zéro fois ou plus
Au moins n fois et au maximum m fois
Au moins n fois
Exactement n fois
Au maximum n fois
Chaîne
b
b
b
Correspondance
Vrai
Vrai
Faux
Vrai
Vrai
Faux
Ces quantificateurs sont des opérateurs gourmands.
C'est-à-dire que la méthode qui cherche le motif dans la chaîne de caractères essaie de le
répéter le caractère le plus possible.
Exemples :
Regex
a+
a*
a{3}
a{3,}
a{3,8}
a{3,8}
dog[3]
Chaîne
aaaaa
aaaaa
aaa
aaaaaaaa
aaaaaaaa
aaaaaaaaaa
doggg
Auteur : Eliana de M.P. Coelho
Correspondance
Vrai, une occurrence : ˮaaaaaˮ
Vrai, deux occurrences : ˮaaaaaˮ et ˮˮ
Vrai, une occurrence : ˮaaaˮ
Vrai, une occurrence : ˮaaaaaaaaˮ
Vrai, une occurrence : ˮaaaaaaaaˮ
Vrai, deux occurrences : ˮaaaaaaaˮ et ˮaaaˮ
Vrai
Groupes
Les parenthèses permettent de regrouper
Regex
^(dog){3}$
^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})$
^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})$
([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})
y{.*}e$
Chaîne
dogdogdog
1986-05-28
001986-05-2800
001986-05-2800
Sylvie
Correspondance
Vrai
Vrai
Faux
Vrai
Vrai
Option
| indique une option
Regex
cat|dog
cat|dog
cat|dog
^cat|dog$
^cat|dog$
^cat|dog$
Chaîne
the cat rubbed my legs
the dog rubbed my legs
the rabbit rubbed my legs
the cat rubbed my legs
cat rubbed my legs
it is a dog
Correspondance
Vrai
Vrai
Faux
Faux
Vrai
Vrai
Caractères spéciaux
Les caractères spéciaux sont :
([{\^$|)?*+.
Si un de ces caractères spéciaux doit se retrouver dans une expression régulière, il faut mettre le
caractère \ devant.
Regex
$5.00
\$5\.00
Chaîne
Votre achat est de $5.00
Votre achat est de $5.00
Correspondance
Faux
Vrai
java.util.regex
Java offre un package pour la manipulation d’expression régulières.
Les classes que nous devons utiliser sont :
Pattern : permet d’avoir une représentation compilée de l’expression régulière
Matcher : permet d’interpréter l’expression régulière et de trouver des correspondances dans
une chaîne de caractères
Auteur : Eliana de M.P. Coelho
Pattern p ; \\ pas besoin de constructeur
Matcher m; \\ pas besoin de constructeur
boolean found = false;
String regex = ˮcatˮ;
String input = ˮcatsˮ;
p = Pattern.compile(regex);
m = p.matcher(input);
while(m.find()) {
System.out.println(ˮLa chaîne \ˮˮ + m.group() +
ˮ\ˮ a été trouvée de la position ˮ + m.start() +
ˮ à la position ˮ m.end() + ˮ. ˮ);
found = true;
}
if(!found){
System.out.println(ˮAucune correspondance trouvée. ˮ);
}
La classe Pattern définie des paramètres optionnels pour changer la façon dont la
correspondance est faite.
Par exemple, pour ne pas distinguer la casse des caractères :
p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
La method split permet d’extraire les sous-chaînes de caractères qui sont entre un pattern :
String regex = ˮ:ˮ;
String input = ˮone:two:three:fourˮ;
Pattern p = Pattern.compile(regex);
String[] items = p.split(input);
for(int i=0; i<items.length; i++) {
System.out.println(items[i]);
}
Sortie :
one
two
three
four
Auteur : Eliana de M.P. Coelho
La méthode replaceAll remplace toutes les occurrences d’une sous-chaîne qui correspondent au
pattern :
String regex = ˮdogˮ;
String input = ˮThe dog says meow. All dogs say meow.ˮ;
String REPLACE = ˮcatˮ;
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(input);
input = m.replaceAll(REPLACE);
System.out.println(input);
Sortie :
The cat says meow. All cats say meow.
La méthode matches de la classe String retourne une valeur booléenne pour indique si la chaîne
correspond à l’expression régulière passée comme paramètre.
myString.matches(ˮexpressionReguliereˮ);
Cela simplifie beaucoup! Il ne faut pas importer le paquettage java.util.regex.
String input = ˮcatsˮ;
if(input.matches(ˮcatsˮ))
System.out.println(ˮLa chaine a ete trouveeˮ);
else
System.out.println(ˮLa chaine n’a pas ete trouveeˮ);
Cependant, la méthode matches retourne vrai ou faux, si la valeur de la chaîne de caractères
correspond entièrement à l’expression régulière passée en paramètre :
String input = ˮcatˮ;
if(input.matches(ˮcatsˮ))
System.out.println(ˮLa chaine a ete trouveeˮ);
else
System.out.println(ˮLa chaine n’a pas ete trouveeˮ);
Pour les caractères spéciaux, la machine regex doit trouver le \. Cependant, si nous mettons un
littéral string dans un programme java, il faut en mettre deux : \\.
String input = ˮcatˮ;
if(input.matches(ˮc\\.sˮ))
System.out.println(ˮLa chaine a ete trouveeˮ);
else
System.out.println(ˮLa chaine n’a pas ete trouveeˮ);
Ceci est dû au fait que le compilateur utilise le \ comme séquence d’échappement. Donc le
compilateur enlève le premier \ et laisse le deuxième qui est passé à regex.
Auteur : Eliana de M.P. Coelho