Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Les expressions régulières en Java

Java fournit le package java.util.regex pour la correspondance de motifs (Pattern matching) avec des expressions régulières.

Une expression régulière est une séquence spéciale de caractères qui vous aide à faire correspondre ou à trouver d'autres chaînes ou ensembles de chaînes, en utilisant une syntaxe spécialisée conservée dans un motif. Elles peuvent être utilisées pour rechercher, éditer ou manipuler du texte et des données.

Le package java.util.regex comprend principalement les trois classes suivantes

  • Classe Pattern - Un objet Pattern est une représentation compilée d'une expression régulière. La classe Pattern ne fournit aucun constructeur public. Pour créer un Pattern, vous devez d'abord appeler l'une de ses méthodes publiques compile(), qui renverront ensuite un objet Pattern. Ces méthodes acceptent une expression régulière comme premier argument.
  • Classe Matcher - Un objet Matcher est le moteur qui interprète le Pattern et effectue des opérations de correspondance avec une chaîne d'entrée. À l'instar de la classe Pattern, Matcher ne définit aucun constructeur public. Vous obtenez un objet Matcher en appelant la méthode matcher() sur un objet Pattern.
  • PatternSyntaxException - Un objet PatternSyntaxException est une exception non contrôlée qui indique une erreur de syntaxe dans un Pattern d'expression régulière.

Groupes de capture 

Les groupes de capture permettent de traiter plusieurs caractères comme une seule et même unité. Ils sont créés en plaçant les caractères à regrouper dans un ensemble de parenthèses. Par exemple, l'expression régulière (abc) crée un seul groupe contenant les lettres "a", "b" et "c".

Les groupes de capture sont numérotés en comptant leurs parenthèses d'ouverture de gauche à droite. Dans l’expression ((A) (B (C))), par exemple, il existe quatre groupes :

  • ((A)(B(C)))
  • (A)
  • (B(C))
  • (C)

Pour savoir combien de groupes sont présents dans l'expression, appelez la méthode groupCount sur un objet Matcher. La méthode groupCount renvoie un entier indiquant le nombre de groupes de capture présents dans le Pattern.

Il existe également un groupe spécial, le groupe 0, qui représente toujours l'expression entière. Ce groupe n'est pas inclus dans le total rapporté par groupCount.

Exemple 1 :
                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            // String to be scanned to find the pattern.
                                            String line = "www.developpement123.com";
                                            String pattern = "(.*)(\\d+)(.*)";
                                    
                                            // créer un objet Pattern
                                            Pattern r = Pattern.compile(pattern);
                                    
                                            // créer un objet Matcher
                                            Matcher m = r.matcher(line);
                                            System.out.println("Nombre de groupes : " + m.groupCount());
                                            if (m.find()) {
                                                System.out.println("Groupe 0 : " + m.group(0));
                                                System.out.println("Groupe 1 : " + m.group(1));
                                                System.out.println("Groupe 2 : " + m.group(2));
                                                System.out.println("Groupe 3 : " + m.group(3));
                                            } else {
                                                System.out.println("NO MATCH");
                                            }
                                    
                                        }
                                    }
                            
Nombre de groupes : 3
Groupe 0 : www.developpement123.com
Groupe 1 : www.developpement12
Groupe 2 : 3
Groupe 3 : .com

Syntaxe des expressions régulières 

Voici le tableau qui répertorie tout les métacharactères d'expression régulière disponibles en Java.

ExpressionCorrespondance
^Correspond au début de la ligne.
$Correspond à la fin de la ligne.
.Correspond à n'importe quel caractère sauf la nouvelle ligne. L'utilisation de l'option m lui permet également de correspondre à la nouvelle ligne.
[...]Correspond à tout caractère entre parenthèses.
[^...]Correspond à tout caractère non placé entre parenthèses.
\ADébut de la chaîne entière.
\zFin de la chaîne entière.
\ZFin de la chaîne entière sauf fin de ligne finale autorisée.
re*Correspond à 0 ou plusieurs occurrences de l'expression précédente.
re+Correspond à 1 ou plusieurs occurrences de l'expression précédente.
re?Correspond à 0 ou 1 occurrence de l'expression précédente.
re{ n}Correspond exactement à n nombre d'occurrences de l'expression précédente.
re{ n,}Correspond à n ou plus d'occurrences de l'expression précédente.
re{ n, m}Correspond à au moins n et au plus m occurrences de l'expression précédente.
a| bCorrespond à a ou b.
(re)Regroupe les expressions régulières et mémorise le texte correspondant.
(?: re)Regroupe les expressions régulières sans mémoriser le texte correspondant.
(?> re)Correspond au motif (Pattern) indépendant sans revenir en arrière.
\wCorrespond aux caractères du mot.
\sCorrespond aux espaces. Équivalent à [\t\n\r\f].
\dCorrespond aux chiffres. Équivalent à [0-9].
\DCorrespond aux non-digits.
\GCorrespond au point où le dernier match s'est terminé.
\nRéférence arrière pour capturer le numéro de groupe "n".
\bCorrespond aux limites de mots en dehors des crochets. Correspond au retour arrière (0x08) à l'intérieur des crochets.
\BCorrespond aux limites non-mot.
\n, \t, etc.Correspond aux nouvelles lignes, aux retours chariots, aux tabs, etc.
\QEchappez tous les caractères jusqu'à \E.
\ETermine la citation commencée avec \Q.

Les métacaractères dans les expressions régulières Java ont une signification particulière. Si vous voulez vraiment faire correspondre ces caractères dans leur forme littérale, et non leur signification de métacaractère, vous devez "échapper" au métacaractère que vous souhaitez associer. Pour échapper à un métacaractère, utilisez le caractère d'échappement des expressions régulières Java, le caractère barre oblique inversée (\). Échapper à un caractère signifie le précéder du caractère barre oblique inversée. Par exemple :

                                \ .
                            

Dans cet exemple, le caractère "." est précédé (échappé) par le caractère \. Une fois échappé, le caractère d’arrêt complet correspond en fait à un caractère d’arrêt complet du texte saisi.

Le métacaractère spécial d'un métacaractère échappé est ignoré - seule sa valeur littérale réelle (par exemple, un arrêt complet) est utilisée.

La syntaxe des expressions régulières Java utilise le caractère barre oblique inversée comme caractère d'échappement, comme dans le cas de String.

Méthodes de la classe Matcher 

Voici une liste de méthodes d'instance utiles

Méthodes d'indexation

Les méthodes d'index fournissent des valeurs d'index utiles qui indiquent précisément où la correspondance a été trouvée dans la chaîne d'entrée

MéthodeDescription
public int start()Retourne l'index de départ du match précédent.
public int start(int group)Retourne l'index de départ de la sous-séquence capturée par le groupe donné lors de la précédente opération de correspondance.
public int end()Retourne le décalage après le dernier caractère trouvé.
public int end(int group)Renvoie le décalage après le dernier caractère de la sous-séquence capturée par le groupe donné lors de l'opération de correspondance précédente.

Méthodes d'étude

Les méthodes d'étude examinent la chaîne d'entrée et renvoient un booléen indiquant si le motif (Pattern) est trouvé ou non

MéthodeDescription
public boolean lookingAt()Essaie de faire correspondre la séquence d'entrée, en commençant au début de la région, avec le motif.
public boolean find()Tente de rechercher la sous-séquence suivante de la séquence d'entrée correspondant au motif.
public boolean find(int start)Réinitialise cet Matcher et tente ensuite de trouver la sous-séquence suivante de la séquence d'entrée correspondant au motif, en commençant à l'index spécifié
public boolean matches()Tente de faire correspondre toute la région au motif (Pattern).

Méthodes de remplacement

Les méthodes de remplacement sont des méthodes utiles pour remplacer du texte dans une chaîne d'entrée

MéthodeDescription
public Matcher appendReplacement(StringBuffer sb, String replacement)Implémente une étape append-and-replace non-terminale.
public StringBuffer appendTail(StringBuffer sb)Implémente une étape terminale append-and-replace.
public String replaceAll(String replacement)Remplace chaque sous-séquence de la séquence d'entrée qui correspond au motif avec la chaîne de remplacement donnée.
public String replaceFirst(String replacement)Remplace la première sous-séquence de la séquence d'entrée qui correspond au modif avec la chaîne de remplacement donnée.
public static String quoteReplacement(String s)Renvoie une chaîne de remplacement littérale pour la chaîne spécifiée. Cette méthode produit une chaîne qui fonctionnera comme un remplacement littéral s dans la méthode appendReplacement de la classe Matcher.

Exemples 

Exemple 1 :
                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Pattern pattern = Pattern.compile("dev");
                                    
                                            // Rechercher le motif ci-dessus dans
                                            // "info-dev : www.developpement-informatique.com"
                                            Matcher m = pattern.matcher("info-dev : www.developpement-informatique.com");
                                    
                                            // afficher les index de début et de fin du motif dans le texte
                                            while (m.find())
                                                System.out.println("Motif trouvé de " + m.start() + " à " + (m.end() - 1));
                                    
                                        }
                                    }
                            
Motif trouvé de 5 à 7
Motif trouvé de 15 à 17
Exemple 2 :

Voici l'exemple qui compte le nombre de fois que le mot "dev" apparaît dans la chaîne de saisie

                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Pattern pattern = Pattern.compile("\\bdev\\b");
                                    
                                            // Rechercher le motif ci-dessus dans
                                            // "info-dev : www.developpement-informatique.com"
                                            Matcher m = pattern.matcher("info dev : www.developpement-informatique.com");
                                    
                                            int cpt = 0;
                                            while (m.find()) {
                                                cpt++;
                                                System.out.println("Mot " + cpt + " : " + m.start() + " à " + (m.end() - 1));
                                            }
                                    
                                        }
                                    }
                            
Mot 1 : 5 à 7

Vous pouvez constater que cet exemple utilise des limites de mots pour garantir que les lettres "d" "e" "v" ne sont pas simplement une sous-chaîne d'un mot plus long. Il fournit également des informations utiles sur l'emplacement de la correspondance dans la chaîne d'entrée.

Exemple 3 :

Les méthodes matches et lookingAt tentent toutes les deux de faire correspondre une séquence d'entrée à un motif. La différence, cependant, est que matches nécessite la correspondance de toute la séquence d'entrée, contrairement à LookingAt.

Les deux méthodes commencent toujours au début de la chaîne d'entrée.

                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Pattern pattern = Pattern.compile("dev");
                                            Matcher matcher = pattern.matcher("developpement-informatique.com");
                                    
                                            System.out.println("lookingAt(): " + matcher.lookingAt());
                                            System.out.println("matches(): " + matcher.matches());
                                        }
                                    }
                            
lookingAt(): true
matches(): false
Exemple 4 :

Les méthodes replaceFirst et replaceAll remplacent le texte correspondant à une expression régulière donnée. Comme leur nom l'indique, replaceFirst remplace la première occurrence et replaceAll remplace toutes les occurrences.

                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Pattern pattern = Pattern.compile("dev");
                                            Matcher matcher = pattern.matcher("info-dev, dev-info");
                                            String res = matcher.replaceAll("soft");
                                    
                                            System.out.println("res : " + res);
                                        }
                                    }
                            
res : info-soft, soft-info
Exemple 5 :

La classe Matcher fournit également des méthodes appendReplacement et appendTail pour le remplacement de texte.

                                    import java.util.regex.Matcher;
                                    import java.util.regex.Pattern;
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Pattern pattern = Pattern.compile("dev");
                                            Matcher matcher = pattern.matcher("info-dev, dev-info");
                                    
                                            StringBuffer res = new StringBuffer();
                                            while (matcher.find()) {
                                                matcher.appendReplacement(res, "soft");
                                            }
                                            matcher.appendTail(res);
                                            System.out.println(res.toString());
                                    
                                            System.out.println("res : " + res);
                                        }
                                    }
                            
res : info-soft, soft-info

Méthodes de classe  PatternSyntaxException 

Une exception PatternSyntaxException est une exception non contrôlée qui indique une erreur de syntaxe dans un motif d'expression régulière. La classe PatternSyntaxException fournit les méthodes suivantes pour vous aider à déterminer ce qui ne va pas.

MéthodeDescription
public String getDescription()Récupère la description de l'erreur.
public int getIndex()Récupère l'index d'erreur.
public String getPattern()Récupère le motif d'expression régulière erroné.
public String getMessage()Renvoie une chaîne multiligne contenant la description de l'erreur de syntaxe et de son index, le motif d'expression régulière erroné et une indication visuelle de l'index d'erreur figurant dans le motif.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :