Java - Expressions régulières

Java fournit le package java.util.regex pour la 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, à l'aide d'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 −

Classe de modèle − 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 invoquer l'un de ses compile() statiques publics méthodes, qui renverront ensuite un objet Pattern. Ces méthodes acceptent une expression régulière comme premier argument.
Classe de correspondance − 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 appelant le matcher() méthode sur un objet Pattern.
Exception de syntaxe de modèle − 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

La capture de groupes est un moyen de traiter plusieurs personnages comme une seule unité. Ils sont créés en plaçant les caractères à grouper à l'intérieur d'un ensemble de parenthèses. Par exemple, l'expression régulière (chien) 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 ouvrantes de gauche à droite. Dans l'expression ((A)(B(C))), par exemple, il y a quatre tels 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 int 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 rapporté par groupCount.

Exemple

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

Démo en direct

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 −

Sortie

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 répertoriant toutes les syntaxes de métacaractères d'expressions régulières disponibles en Java −

Sous-expression	Correspondances
^	Correspond au début de la ligne.
$	Correspond à la fin de la ligne.
.	Correspond à n'importe quel caractère unique à l'exception de la nouvelle ligne. Utilisation de m l'option lui permet également de correspondre à la nouvelle ligne.
[...]	Reconnaît n'importe quel caractère entre parenthèses.
[^...]	Reconnaît n'importe quel caractère non entre parenthèses.
\A	Début de la chaîne entière.
\z	Fin de la chaîne entière.
\Z	Fin de la chaîne entière sauf le terminateur de ligne final autorisé.
re*	Correspond à 0 ou plusieurs occurrences de l'expression précédente.
re+	Correspond à 1 ou plusieurs éléments précédents.
re ?	Reconnaît 0 ou 1 occurrence de l'expression précédente.
re{ n}	Reconnaît exactement n nombre d'occurrences de l'expression précédente.
re{ n,}	Reconnaît n ou plusieurs occurrences de l'expression précédente.
re{ n, m}	Reconnaît au moins n et au plus m occurrences de l'expression précédente.
a\| b	Correspond à 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)	Reconnaît le motif indépendant sans retour en arrière.
\w	Reconnaît les caractères du mot.
\W	Reconnaît les caractères non verbaux.
\s	Correspond à l'espace blanc. Équivalent à [\t\n\r\f].
\S	Correspond à l'espace non blanc.
\d	Reconnaît les chiffres. Équivalent à [0-9].
\D	Reconnaît les 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	Correspond au point où la dernière correspondance s'est terminée.
\n	Référence pour capturer le numéro de groupe "n".
\b	Reconnaît les limites du mot lorsqu'il est en dehors des crochets. Correspond à l'espacement arrière (0x08) lorsqu'il est à l'intérieur des crochets.
\B	Correspond aux limites des non-mots.
\n, \t, etc.	Reconnaît les nouvelles lignes, les retours chariot, les tabulations, etc.
\Q	Échapper (guillemets) tous les caractères jusqu'à \E.
\E	Finit les citations commençant par \Q.

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 montrent précisément où la correspondance a été trouvée dans la chaîne d'entrée −

public int start()

Renvoie l'index de début de la correspondance précédente.

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.

public int end()

Renvoie le décalage après le dernier caractère correspondant.

public int end(int groupe)

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.

Sr.No.	Méthode et description
1
2
3
4

Méthodes d'étude

Les méthodes d'étude examinent la chaîne d'entrée et renvoient un booléen indiquant si le modèle est trouvé ou non −

booléen public 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.

recherche booléenne publique()

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

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

correspondances booléennes publiques()

Tente de faire correspondre la région entière au motif.

Sr.No.	Méthode et description
1
2
3
4

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 −

public Matcher appendReplacement(StringBuffer sb, remplacement de chaîne)

Implémente une étape d'ajout et de remplacement non terminal.

public StringBuffer appendTail(StringBuffer sb)

Implémente une étape d'ajout et de remplacement de terminal.

chaîne publique replaceAll(remplacement de chaîne)

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.

chaîne publique replaceFirst(remplacement de chaîne)

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.

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.

Sr.No.	Méthode et description
1
2
3
4
5

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 −

Exemple

Démo en direct

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 −

Sortie

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 simplement une sous-chaîne dans un mot plus long. Il donne également des informations utiles sur l'endroit où la correspondance s'est produite dans la chaîne d'entrée.

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 méthode end renvoie l'index du dernier caractère correspondant, plus un.

Les correspondances et les méthodes lookingAt

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 matches nécessite que la séquence d'entrée entière 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é −

Exemple

Démo en direct

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 −

Sortie

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 leurs noms l'indiquent, replaceFirst remplace la première occurrence et replaceAll remplace toutes les occurrences.

Voici l'exemple expliquant la fonctionnalité −

Exemple

Démo en direct

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 −

Sortie

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

Exemple

Démo en direct

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 −

Sortie

-foo-foo-foo-

Méthodes de la 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 s'est mal passé −

chaîne publique getDescription()

Récupère la description de l'erreur.

public int getIndex()

Récupère l'index d'erreur.

chaîne publique getPattern()

Récupère le modèle d'expression régulière erroné.

chaîne publique 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.

Sr.No.	Méthode et description
1
2
3
4

Java - Date et heure Java - Méthodes

Java