Java - Expressions régulières

Java fournit le package java.util.regex pour la mise en correspondance de modèles avec des expressions régulières. Les expressions régulières Java sont très similaires au langage de programmation Perl et très faciles à 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 contenue dans un modèle. Ils peuvent être utilisés pour rechercher, modifier ou manipuler du texte et des données.

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

  • Pattern Class- 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 modèle, vous devez d'abord appeler l'un de ses statiques publicscompile()méthodes, qui renverront ensuite un objet Pattern. Ces méthodes acceptent une expression régulière comme premier argument.

  • Matcher Class- Un objet Matcher est le moteur qui interprète le modèle et effectue des opérations de correspondance sur une chaîne d'entrée. Comme la classe Pattern, Matcher ne définit aucun constructeur public. Vous obtenez un objet Matcher en invoquant lematcher() méthode sur un objet Pattern.

  • 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.

Capture de groupes

Les groupes de capture sont un moyen de traiter plusieurs personnages comme une seule unité. Ils sont créés en plaçant les caractères à regrouper dans un jeu de parenthèses. Par exemple, l'expression régulière (chien) crée un groupe unique contenant les lettres «d», «o» et «g».

Les groupes de capture sont numérotés en comptant leurs parenthèses d'ouverture de la gauche vers la droite. Dans l'expression ((A) (B (C))), par exemple, il y a 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 matcher. La méthode groupCount renvoie unint montrant le nombre de groupes de capture présents dans le modèle du matcher.

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 déclaré par groupCount.

Example

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 produira le résultat suivant -

Output

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

Syntaxe des expressions régulières

Voici le tableau listant toute la syntaxe de métacaractère d'expression régulière disponible en Java -

Sous-expression Allumettes
^ Correspond au début de la ligne.
$ Correspond à la fin de la ligne.
. Correspond à n'importe quel caractère unique sauf le saut de ligne. En utilisantm L'option lui permet également de correspondre à la nouvelle ligne.
[...] Correspond à n'importe quel caractère unique entre crochets.
[^ ...] Correspond à tout caractère unique non entre crochets.
\UNE Début de la chaîne entière.
\ z Fin de la chaîne entière.
\ Z Fin de la chaîne entière à l'exception de la terminaison de ligne finale autorisée.
ré* Correspond à 0 occurrences ou plus de l'expression précédente.
re + Correspond à 1 ou plusieurs éléments précédents.
ré? Correspond à 0 ou 1 occurrence de l'expression précédente.
re {n} Correspond exactement au nombre n d'occurrences de l'expression précédente.
re {n,} Correspond à n occurrences ou plus 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 à a ou b.
(ré) Regroupe les expressions régulières et mémorise le texte correspondant.
(?: re) Regroupe les expressions régulières sans se souvenir du texte correspondant.
(?> re) Correspond au modèle indépendant sans retour en arrière.
\ w Correspond aux caractères du mot.
\ W Correspond aux caractères non-mots.
\ s Correspond à l'espace blanc. Équivaut à [\ t \ n \ r \ f].
\ S Correspond à l'espace non blanc.
\ré Correspond aux chiffres. Équivalent à [0-9].
\RÉ Correspond aux non-chiffres.
\UNE 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 Correspond au point où le dernier match s'est terminé.
\ n Référence arrière pour capturer le numéro de groupe "n".
\ b Correspond aux limites du mot en dehors des crochets. Correspond à l'espace arrière (0x08) à l'intérieur des crochets.
\ B Correspond aux limites non-mot.
\ n, \ t, etc. Correspond aux retours à la ligne, aux retours chariot, aux tabulations, etc.
\ Q Échappez (citez) tous les caractères jusqu'à \ E.
\ E Fin des citations commencées 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 où la correspondance a été trouvée dans la chaîne d'entrée -

N ° Sr. Méthode et 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ée 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 correspondant.

4

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 est trouvé ou non -

N ° Sr. Méthode et description
1

public boolean lookingAt()

Tente de faire correspondre la séquence d'entrée, en commençant au début de la région, avec le modèle.

2

public boolean find()

Tente de trouver la sous-séquence suivante de la séquence d'entrée qui correspond au modèle.

3

public boolean find(int start)

Réinitialise ce matcher, puis tente de trouver la sous-séquence suivante de la séquence d'entrée qui correspond au modèle, en commençant à l'index spécifié.

4

public boolean matches()

Tente de faire correspondre toute la région au modèle.

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 -

N ° Sr. Méthode et 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)

Implémente 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 modèle par 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 modèle par 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érals dans la méthode appendReplacement de la classe Matcher.

Les méthodes de début et de fin

Voici l'exemple qui compte le nombre de fois où le mot «chat» apparaît dans la chaîne d'entrée -

Example

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 produira le résultat suivant -

Output

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 mot pour garantir que les lettres "c" "a" "t" ne sont pas simplement une sous-chaîne d'un mot plus long. Il donne également des informations utiles sur l'emplacement de la chaîne d'entrée où la correspondance s'est produite.

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

Les correspondances et les méthodes de recherche

Les méthodes matches et lookingAt tentent toutes deux de faire correspondre une séquence d'entrée à un modèle. La différence, cependant, est que les correspondances nécessitent que toute la séquence d'entrée soit mise en correspondance, contrairement à lookingAt.

Les deux méthodes commencent toujours au début de la chaîne d'entrée. Voici l'exemple expliquant la fonctionnalité -

Example

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

Cela produira le résultat suivant -

Output

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

Example

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 produira le résultat suivant -

Output

The cat says meow. All cats say meow.

Les méthodes appendReplacement et appendTail

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

Voici l'exemple expliquant la fonctionnalité -

Example

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 produira le résultat suivant -

Output

-foo-foo-foo-

Méthodes de classe PatternSyntaxException

Une 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 n'a pas fonctionné -

N ° Sr. Méthode et 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 modèle d'expression régulière erroné.

4

public String getMessage()

Renvoie une chaîne multiligne contenant la description de l'erreur de syntaxe et son index, le modèle d'expression régulière erroné et une indication visuelle de l'index d'erreur dans le modèle.