Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les expressions régulières

La Programmation Orientée Objet en Java : Les expressions régulières

Java fournit le paquetage java.util.regex pour la correspondance de modèles avec des expressions régulières. Les expressions régulières de Java sont très semblables au langage de programmation Perl et très facile à apprendre.

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 détenue dans un motif. Ils peuvent être utilisés pour rechercher, éditer ou manipuler du texte et des données.

Le package java.util.regex se compose principalement des trois classes suivantes:

  • Classe Pattern : un objet Pattern (motif) est une représentation compilée d'une expression régulière. La classe Pattern ne fournit pas de constructeurs publics. Pour créer un motif, vous devez d'abord invoquer une de ses méthodes publiques de compilation statique, qui renverra alors 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 motif et exécute les opérations de correspondance par rapport à une chaîne d'entrée. Comme la classe Pattern, Matcher ne définit aucun constructeur public. Vous obtenez un objet Matcher en invoquant la méthode Matcher sur un objet Pattern.
  • Classe PatternSyntaxException : Un objet PatternSyntaxException est une exception non vérifiée qui indique une erreur de syntaxe dans un modèle d'expression régulière.

Capturer des groupes

Les groupes de capture sont un moyen de traiter plusieurs caractères comme une seule 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 (dog) crée un seul groupe contenant les lettres "d", "o" et "g".

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 de ce type:

  • ((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 matché. La méthode groupCount renvoie un entier montrant le nombre de groupes de capture présents dans le modèle matché.

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 nombre renvoyé par la méthode groupCount.

Exemple:

L'exemple suivant illustre comment trouver une chaîne de chiffres à partir de la chaîne alphanumérique donnée:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    public static void main( String args[] ){
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";
      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);
      // Now create matcher object.
      Matcher m = r.matcher(line);
      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

 Cela produirait le résultat suivant:

Found value: This order was placed for QT3000! OK?

Found value: This order was placed for QT300

Found value: 0

Syntaxe d'expression régulière

Voici le tableau répertoriant la syntaxe métacaractrique d'expression régulière disponible en Java:

Sous-expression

Matches

^

Correspond au début de la ligne.

$

Correspond à la fin de la ligne.

.

Correspond à un seul caractère, à l'exception de la nouvelle ligne. L'utilisation de l'option m permet de faire correspondre la nouvelle ligne.

[...]

Correspond à un seul caractère entre parenthèses.

[^...]

Correspond à un seul caractère qui n'est pas entre parenthèses

\A

Début de la chaîne entière

\z

Fin de chaîne entière

\Z

Fin de chaîne entière, sauf terminaison de ligne finale admissible.

re*

Correspond à 0 ou plus des occurrences de l'expression précédente.

re+

Correspond à 1 ou plus occurrence de l'expression précédente

re?

Correspond à 0 ou 1 occurrence de l'expression précédente.

re{n}

Correspond exactement au n nombre d'occurrences de l'expression précédente.

re{n,}

Correspond à n ou plusieurs 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 | B

Correspond à un A ou à un B.

(re)

Groupes d'expressions régulières et rappelle le texte apparié.

(?:re)

Groupes d’expressions régulières sans se souvenir du texte apparié.

(?>re)

Correspond à un schéma indépendant sans retour en arrière.

\w

Correspond à des mots.

\W

Correspond aux caractères non-mots.

\s

Correspond à l'espace blanc. Equivalent à [\ t \ n \ r \ f].

\S

Correspond à l’espace non blanc .

\d

Correspond à des chiffres. Equivalent à [0-9].

\D

Correspond à des non chiffres.

\A

Correspond au début de la chaîne.

\Z

Correspond à la fin de la chaîne. Si une nouvelle ligne existe, elle correspond juste avant la nouvelle ligne.

\z

Correspond à la fin de la chaîne.

\G

Les matchs indiquent le dernier match terminé.

\n

Renvoi vers le numéro de groupe de capture "n"

\b

Correspond aux limites des mots lorsque les parenthèses extérieures. Correspond à l'arrière (0x08) dans les parenthèses entre parenthèses.

\B

Correspond aux limites de non-mots.

\n, \t, etc.

Correspond aux nouvelles lignes, retours chariot, tabulation, etc.

\Q

Escape (quote) tous les caractères jusqu'à \E

\E

Fin de quote commençant par \Q

Méthodes de la classe Matcher

Voici une liste de méthodes d'instance utiles:

Méthodes d'index

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

SN

Méthodes avec description

1

public int start() 
Renvoie l'index de début de la correspondance précédente.

2

public int start(int group) 
Renvoie l'index de début de la sous-séquence capturé par le groupe donné lors de l'opération de correspondance précédente.

3

public int end() 
Renvoie le décalage après le dernier caractère adapté.

4

public int end(int group) 
Renvoie le décalage après le dernier caractère de la sous-séquence capturé 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 de saisie et renvoient un booléen indiquant si le motif est ou non trouvé:

SN

Méthodes avec description

1

public boolean lookingAt() 
Essayer de faire correspondre la séquence d'entrée, en commençant au début de la région, contre le motif.

2

public boolean find()
Essayer de trouver la suite suivante de la séquence d'entrée qui correspond au motif.

3

public boolean find(int start)
Réinitialise ce matcher, puis tente de trouver la suite suivante de la séquence d'entrée qui correspond au motif, en commençant par l'index spécifié.

4

public boolean matches()
Les tentatives pour correspondre à la région entière contre le motif.

Méthodes de remplacement

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

SN

Méthodes avec description

1

public Matcher appendReplacement(StringBuffer sb, String replacement)
Implémente une étape d'ajout et de remplacement non-terminale.

2

public StringBuffer appendTail(StringBuffer sb)
Implique une étape d'ajout et de remplacement de terminal.

3

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.

4

public String replaceFirst(String replacement)
Remplace la première sous-séquence de la séquence d'entrée qui correspond au motif avec la chaîne de remplacement donnée.

5

            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 dans la méthode AppendReplacement de la classe Matcher.

Les méthodes start et end

Voici l'exemple qui compte le nombre de fois que le mot "cats" apparaît dans la chaîne d'entrée:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "\\bcat\\b";
    private static final String INPUT = "cat cat cat cattie cat";

    public static void main( String args[] ){
       Pattern p = Pattern.compile(REGEX);
       Matcher m = p.matcher(INPUT); // get a matcher object
       int count = 0;

       while(m.find()){
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

 Cela produirait le résultat suivant:

Match number 1

start(): 0

end(): 3

Match number 2

start(): 4

end(): 7

Match number 3

start(): 8

end(): 11

Match number 4

start(): 19

end(): 22

 Vous pouvez voir que cet exemple utilise des limites de mots pour s'assurer que les lettres "c" "a" "t" ne sont pas seulement une sous-chaîne dans un mot plus long. Il fournit également des informations utiles sur l'endroit où la chaîne d'entrée a eu lieu.

La méthode start renvoie l'indice de début de la sous-séquence capturé par le groupe donné lors de l'opération de correspondance précédente, et la méthode end renvoie l'indice du dernier caractère apparié, plus un.

Les méthodes  matches et lookingAt

Les méthodes matches et lookingAt tentent toutes deux d'associer une séquence d'entrée à un modèle. La différence, cependant, est que les correspondances exigent que la séquence d'entrée entière soit adaptée, alors que lookingAt ne l'est pas.

Les deux méthodes commencent toujours au début de la chaîne de saisie. Voici l'exemple expliquant les fonctionnalités:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static final String REGEX = "foo";
    private static final String INPUT = "fooooooooooooooooo";
    private static Pattern pattern;
    private static Matcher matcher;

    public static void main( String args[] ){
       pattern = Pattern.compile(REGEX);
       matcher = pattern.matcher(INPUT);

       System.out.println("Current REGEX is: "+REGEX);
       System.out.println("Current INPUT is: "+INPUT);

       System.out.println("lookingAt(): "+matcher.lookingAt());
       System.out.println("matches(): "+matcher.matches());
   }
}

Current REGEX is: foo

Current INPUT is: fooooooooooooooooo

lookingAt(): true

matches(): false

Les méthodes replaceFirst et replaceAll

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

Voici l'exemple expliquant les fonctionnalités:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
    private static String REGEX = "dog";
    private static String INPUT = "The dog says meow. " +
                                    "All dogs say meow.";
    private static String REPLACE = "cat";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       // get a matcher object
       Matcher m = p.matcher(INPUT);
       INPUT = m.replaceAll(REPLACE);
       System.out.println(INPUT);
   }
}

 Cela produirait le résultat suivant:

The cat says meow. All cats say meow.

Les méthodes appendReplacement et appendTail

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

Voici l'exemple expliquant les fonctionnalités:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexMatches
{
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

 Cela produirait le résultat suivant:

-foo-foo-foo-

Méthodes de classe PatternSyntaxException

Une exception PatternSyntaxException est une exception non vérifiée qui indique une erreur de syntaxe dans un modèle d'expression régulière. La classe PatternSyntaxException fournit les méthodes suivantes pour vous aider à déterminer ce qui a mal tourné:

SN

Méthodes avec description

1

public String getDescription()
Récupère la description de l'erreur.

2

public int getIndex()
Récupère l'index d'erreur.

3

public String getPattern() 
Récupère le motif d'expression régulier erroné.

4

public String getMessage() 
Renvoie une chaîne multi-lignes contenant la description de l'erreur de syntaxe et son index, le motif d'expression régulier erroné et une indication visuelle de l'index d'erreur.

 




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les expressions régulières