Expressions régulières en Java, partie 1

Nous attirons votre attention sur la traduction d'un petit guide des expressions régulières en langage Java, rédigé par Jeff Friesen pour le site JavaWorld . Pour faciliter la lecture, nous avons divisé l'article en plusieurs parties.

Utilisation de l'API d'expression régulière dans les programmes Java pour reconnaître et décrire des modèles

Les caractères Java et divers types de données chaîne fournissent un support de bas niveau pour la correspondance de modèles, mais leur utilisation à cette fin ajoute généralement une complexité de code significative. Un code plus simple et plus performant est obtenu en utilisant l'API Regex ("Regular Expression API"). Ce didacticiel vous aidera à démarrer avec les expressions régulières et l'API Regex. Nous discuterons d'abord des trois classes les plus intéressantes du package en général java.util.regex, puis examinerons l'intérieur de la classe Patternet explorerons ses constructions sophistiquées de correspondance de modèles. Attention: Vous pouvez télécharger le code source (créé par Jeff Friesen pour le site JavaWorld) de l'application de démonstration à partir de cet article à partir d'ici .

Que sont les expressions régulières ?

Une expression régulière (expression régulière/regex/regexp) est une chaîne qui est un modèle qui décrit un certain ensemble de chaînes. Le modèle détermine quelles lignes appartiennent à l'ensemble. Le modèle se compose de littéraux et de métacaractères, des caractères ayant une signification particulière plutôt qu'une signification littérale. La correspondance de modèles est une recherche de texte pour trouver des correspondances, c'est-à-dire des chaînes qui correspondent à un modèle d'expression régulière. Java prend en charge la correspondance de modèles via son API Regex. Cette API se compose de trois classes : Pattern, Matcheret PatternSyntaxException, situées dans le package java.util.regex:

• les objets de classe Pattern, également appelés modèles, sont des expressions régulières compilées.
• Les objets de classe Matcher, ou matchers, sont des mécanismes d'interprétation de modèles permettant de rechercher des correspondances dans des séquences de caractères (objets dont les classes implémentent une interface java.lang.CharSequenceet servent de sources de texte).
• Les objets de classe PatternSyntaxExceptionsont utilisés pour décrire des modèles d'expressions régulières non valides.

Java prend également en charge la correspondance de modèles via diverses méthodes du java.lang.String. Par exemple, la fonction ne boolean matches (String regex)renvoie trueque si la chaîne appelante correspond exactement à l'expression régulière regex.

RegexDémo

J'ai créé une application RegexDemopour démontrer les expressions régulières Java et diverses méthodes de Pattern, Matcheret PatternSyntaxException. Vous trouverez ci-dessous le code source de cette application de démonstration. Listing 1. Démonstration d'expression régulière

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
public class RegexDemo
{
   public static void main(String[] args)
   {
      if (args.length != 2)
      {
         System.err.println("usage: java RegexDemo regex input");
         return;
      }
      // Преобразуем символьные последовательности начала новой строки (\n) в символы начала строки.
      args[1] = args[1].replaceAll("\\\\n", "\n");
      try
      {
         System.out.println("regex = " + args[0]);
         System.out.println("input = " + args[1]);
         Pattern p = Pattern.compile(args[0]);
         Matcher m = p.matcher(args[1]);
         while (m.find())
            System.out.println("Found [" + m.group() + "] starting at "
                               + m.start() + " and ending at " + (m.end() - 1));
      }
      catch (PatternSyntaxException pse)
      {
         System.err.println("Неправильное регулярное выражение: " + pse.getMessage());
         System.err.println("Описание: " + pse.getDescription());
         System.err.println("Позиция: " + pse.getIndex());
         System.err.println("Неправильный шаблон: " + pse.getPattern());
      }
   }
}

La première chose que fait une méthode mainde classe RegexDemoest de vérifier sa ligne de commande. Cela nécessite deux arguments : le premier est une expression régulière et le second est le texte d'entrée dans lequel l'expression régulière sera recherchée. Vous devrez peut-être utiliser un caractère de nouvelle ligne dans le texte saisi (\n). Cela ne peut être fait qu'en spécifiant le caractère \suivi du caractère n. La fonction main()convertit cette séquence de caractères en valeur Unicode 10. La majeure partie du code RegexDemoest entourée du try-catch. Le bloc trygénère d'abord l'expression régulière donnée et le texte d'entrée, puis crée un objet Patternqui stocke l'expression régulière compilée (les expressions régulières sont compilées pour améliorer les performances de correspondance de modèles). Un matcher est extrait de l'objet Patternet utilisé pour rechercher des correspondances de manière itérative jusqu'à ce qu'elles soient toutes trouvées. Le bloc catchappelle plusieurs méthodes de classe PatternSyntaxExceptionpour récupérer des informations utiles sur l'exception. Ces informations sont transmises séquentiellement au flux de sortie. Il n'est pas encore nécessaire de connaître les détails du fonctionnement du code : ils deviendront clairs lorsque nous étudierons l'API dans la deuxième partie de l'article. Cependant, vous devez compiler le listing 1. Prenez le code du listing 1, puis tapez la commande suivante à l'invite de commande pour compilerRegexDemo : javac RegexDemo.java

La classe Pattern et ses constructions

La classe Pattern, la première des trois classes qui composent l'API Regex, est une représentation compilée d'une expression régulière. La documentation du SDK de classe Patterndécrit diverses constructions d'expressions régulières, mais si vous n'utilisez pas activement d'expressions régulières, certaines parties de cette documentation peuvent prêter à confusion. Que sont les quantificateurs et quelle est la différence entre les quantificateurs gourmands, réticents et possessifs ? Que sont les classes de caractères, les comparateurs de limites, les références arrière et les expressions de drapeau intégrées ? Je répondrai à ces questions et à d’autres dans les sections suivantes.

Chaînes littérales

La construction d’expression régulière la plus simple est une chaîne littérale. Pour que la correspondance de modèle réussisse, une partie du texte saisi doit correspondre au modèle de cette construction. Prenons l'exemple suivant : java RegexDemo apple applet Dans cet exemple, nous essayons de trouver une correspondance pour un modèle appledans le texte saisi applet. Le résultat suivant montre la correspondance trouvée :

regex = apple
input = applet
Found [apple] starting at 0 and ending at 4

Nous voyons dans la sortie l'expression régulière et le texte d'entrée, puis une indication de détection réussie appledans l'applet. De plus, les positions de départ et d'arrivée de ce match sont indiquées : 0et 4, respectivement. La position de départ indique le premier endroit du texte où une correspondance a été trouvée, et la position de fin indique le dernier point de la correspondance. Supposons maintenant que nous donnions la ligne de commande suivante : java RegexDemo apple crabapple Cette fois, nous obtenons le résultat suivant, avec des positions de début et de fin différentes :

regex = apple
input = crabapple
Found [apple] starting at 4 and ending at 8

Sinon, avec et appletcomme expression régulière apple- le texte saisi, aucune correspondance ne sera trouvée. L'expression régulière entière doit correspondre, mais dans ce cas, le texte saisi ne contient pas tafter apple.

Métacaractères

Des constructions d'expressions régulières plus intéressantes combinent des caractères littéraux avec des métacaractères. Par exemple, dans une expression régulière a.b, le métacaractère point (.)désigne tout caractère compris entre aet b. Prenons l'exemple suivant : java RegexDemo .ox "The quick brown fox jumps over the lazy ox." Cet exemple utilise .oxà la fois comme expression régulière et The quick brown fox jumps over the lazy ox.comme texte d'entrée. RegexDemorecherche dans le texte des correspondances commençant par n'importe quel caractère et se terminant par ox.Les résultats de son exécution sont les suivants :

regex = .ox
input = The quick brown fox jumps over the lazy ox.
Found [fox] starting at 16 and ending at 18
Found [ ox] starting at 39 and ending at 41

Dans la sortie, nous voyons deux correspondances : foxet ox(avec un espace devant). Le métacaractère . correspond à un caractère fdans le premier cas et à un espace dans le second. Que se passe-t-il si vous le remplacez .oxpar un métacaractère .? Autrement dit, ce que nous obtenons à la suite de la ligne de commande suivante : java RegexDemo . "The quick brown fox jumps over the lazy ox." Puisque le métacaractère point correspond à n'importe quel caractère, RegexDemoles correspondances trouvées pour tous les caractères (y compris le caractère point final) du texte saisi seront affichées :

regex = .
input = The quick brown fox jumps over the lazy ox.
Found [T] starting at 0 and ending at 0
Found [h] starting at 1 and ending at 1
Found [e] starting at 2 and ending at 2
Found [ ] starting at 3 and ending at 3
Found [q] starting at 4 and ending at 4
Found [u] starting at 5 and ending at 5
Found [i] starting at 6 and ending at 6
Found [c] starting at 7 and ending at 7
Found [k] starting at 8 and ending at 8
Found [ ] starting at 9 and ending at 9
Found [b] starting at 10 and ending at 10
Found [r] starting at 11 and ending at 11
Found [o] starting at 12 and ending at 12
Found [w] starting at 13 and ending at 13
Found [n] starting at 14 and ending at 14
Found [ ] starting at 15 and ending at 15
Found [f] starting at 16 and ending at 16
Found [o] starting at 17 and ending at 17
Found [x] starting at 18 and ending at 18
Found [ ] starting at 19 and ending at 19
Found [j] starting at 20 and ending at 20
Found [u] starting at 21 and ending at 21
Found [m] starting at 22 and ending at 22
Found [p] starting at 23 and ending at 23
Found [s] starting at 24 and ending at 24
Found [ ] starting at 25 and ending at 25
Found [o] starting at 26 and ending at 26
Found [v] starting at 27 and ending at 27
Found [e] starting at 28 and ending at 28
Found [r] starting at 29 and ending at 29
Found [ ] starting at 30 and ending at 30
Found [t] starting at 31 and ending at 31
Found [h] starting at 32 and ending at 32
Found [e] starting at 33 and ending at 33
Found [ ] starting at 34 and ending at 34
Found [l] starting at 35 and ending at 35
Found [a] starting at 36 and ending at 36
Found [z] starting at 37 and ending at 37
Found [y] starting at 38 and ending at 38
Found [ ] starting at 39 and ending at 39
Found [o] starting at 40 and ending at 40
Found [x] starting at 41 and ending at 41
Found [.] starting at 42 and ending at 42

Classes de personnages

Parfois, vous devez limiter les correspondances que vous recherchez à un ensemble spécifique de caractères. Par exemple, recherchez dans le texte les voyelles a, e, i, oet u, chaque occurrence d'une voyelle étant considérée comme une correspondance. Pour résoudre de tels problèmes, nous serons aidés par des classes de caractères qui définissent des ensembles de caractères entre les métacaractères des crochets ( [ ]). La classe Patternprend en charge les classes de caractères simples, les classes de plage, les classes inverses, d'union, d'intersection et de soustraction. Nous allons tous les examiner maintenant.

Classes de personnages simples

Une classe de caractères simple se compose de caractères placés côte à côte et correspond uniquement à ces caractères. Par exemple, la classe [abc]correspond aux caractères a, bet c. Prenons l'exemple suivant : java RegexDemo [csw] cave Comme vous pouvez le voir d'après les résultats, dans cet exemple, uniquement le caractère cpour lequel il existe une correspondance danscave :

regex = [csw]
input = cave
Found [c] starting at 0 and ending at 0

Classes de caractères inversées

Une classe de caractères inversée commence par un métacaractère ^et correspond uniquement aux caractères qui n'y figurent pas. Par exemple, la classe [^abc]correspond à tous les caractères sauf a, bet c. Prenons l'exemple suivant : java RegexDemo "[^csw]" cave Notez que sur mon système d'exploitation (Windows), les guillemets doubles sont requis car le shell les traite ^comme un caractère d'échappement. Comme vous pouvez le voir, dans cet exemple, seuls les caractères a, vet ont été trouvés epour lesquels il existe des correspondances danscave :

regex = [^csw]
input = cave
Found [a] starting at 1 and ending at 1
Found [v] starting at 2 and ending at 2
Found [e] starting at 3 and ending at 3

Classes de caractères de plage

Une classe de caractères de plage se compose de deux caractères séparés par un trait d'union ( -). Tous les caractères, commençant par le caractère à gauche du trait d'union et se terminant par le caractère à droite, font partie de la plage. Par exemple, la plage [a-z]correspond à toutes les lettres latines minuscules. Cela équivaut à définir une classe simple [abcdefghijklmnopqrstuvwxyz]. Prenons l'exemple suivant : java RegexDemo [a-c] clown Cet exemple ne correspondra qu'au caractère cqui correspond àclown :

regex = [a-c]
input = clown
Found [c] starting at 0 and ending at 0

Expressions régulières en Java, partie 2 Expressions régulières en Java, partie 3 Expressions régulières en Java, partie 4 Expressions régulières en Java, partie 5