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.

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");
                                            }
                                    
                                        }
                                    }
                            

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

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.

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é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

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

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));
                                    
                                        }
                                    }
                            

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));
                                            }
                                    
                                        }
                                    }
                            

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());
                                        }
                                    }
                            

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);
                                        }
                                    }
                            

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);
                                        }
                                    }
                            

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.