Java Regex - Guide rapide

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.

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.

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

Production

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

introduction

le java.util.regex.MatchResultinterface représente le résultat d'une opération de correspondance. Cette interface contient des méthodes de requête utilisées pour déterminer les résultats d'une correspondance avec une expression régulière. Les limites de correspondance, les groupes et les limites de groupe peuvent être vus mais pas modifiés via un MatchResult.

Déclaration d'interface

Voici la déclaration pour java.util.regex.MatchResult interface -

public interface MatchResult

Méthodes d'interface

Sr.Non	Méthode et description
1	int fin () Renvoie le décalage après le dernier caractère correspondant.
2	int end (groupe int) Renvoie le décalage après le dernier caractère de la sous-séquence capturée par le groupe donné pendant cette correspondance.
3	Groupe de chaînes () Renvoie la sous-séquence d'entrée correspondant à la correspondance précédente.
4	Groupe de chaînes (groupe int) Renvoie la sous-séquence d'entrée capturée par le groupe donné lors de l'opération de correspondance précédente.
5	int groupCount () Renvoie le nombre de groupes de capture dans le modèle de ce résultat de correspondance.
6	int début () Renvoie l'index de début de la correspondance.
sept	int start (groupe int) Renvoie l'index de début de la sous-séquence capturée par le groupe donné lors de cette correspondance.

introduction

le java.util.regex.Pattern class représente une représentation compilée d'une expression régulière.

Déclaration de classe

Voici la déclaration pour java.util.regex.Pattern classe -

public final class Pattern
   extends Object
      implements Serializable

Champ

Voici les champs pour java.util.regex.Duration classe -

• static int CANON_EQ - Active l'équivalence canonique.

• static int CASE_INSENSITIVE - Active la correspondance insensible à la casse.

• static int COMMENTS - Autorise les espaces et les commentaires dans le modèle.

• static int DOTALL - Active le mode dotall.

• static int LITERAL - Active l'analyse littérale du modèle.

• static int MULTILINE - Active le mode multiligne.

• static int UNICODE_CASE - Active le pliage de valise compatible Unicode.

• static int UNICODE_CHARACTER_CLASS - Active la version Unicode des classes de caractères prédéfinies et des classes de caractères POSIX.

• static int UNIX_LINES - Active le mode lignes Unix.

Méthodes de classe

Sr.Non	Méthode et description
1	Compilation de modèles statiques (String regex) Compile l'expression régulière donnée dans un modèle.
2	Compilation de modèles statiques (String regex, int flags) Compile l'expression régulière donnée dans un modèle avec les indicateurs donnés.
3	indicateurs int () Renvoie les indicateurs de correspondance de ce modèle.
4	Matcher matcher (entrée CharSequence) Crée un matcher qui correspondra à l'entrée donnée avec ce modèle.
5	correspondances booléennes statiques (String regex, entrée CharSequence) Compile l'expression régulière donnée et tente de faire correspondre l'entrée donnée avec elle.
6	Modèle de chaîne () Renvoie l'expression régulière à partir de laquelle ce modèle a été compilé.
sept	guillemet de chaîne statique (chaîne s) Renvoie une chaîne de modèle littérale pour la chaîne spécifiée.
8	String [] split (entrée CharSequence) Divise la séquence d'entrée donnée autour des correspondances de ce modèle.
9	String [] split (entrée CharSequence, limite int) Divise la séquence d'entrée donnée autour des correspondances de ce modèle.
dix	Chaîne toString () Renvoie la représentation sous forme de chaîne de ce modèle.

Méthodes héritées

Cette classe hérite des méthodes des classes suivantes -

• Java.lang.Object

introduction

le java.util.regex.Matcher class agit comme un moteur qui effectue des opérations de correspondance sur une séquence de caractères en interprétant un Pattern.

Déclaration de classe

Voici la déclaration pour java.util.regex.Matcher classe -

public final class Matcher
   extends Object
      implements MatchResult

Méthodes de classe

Sr.Non	Méthode et description
1	Matcher appendReplacement (StringBuffer sb, remplacement de chaîne) Implémente une étape d'ajout et de remplacement non terminale.
2	StringBuffer appendTail (StringBuffer sb) Implémente une étape d'ajout et de remplacement de terminal.
3	int fin () Renvoie le décalage après le dernier caractère correspondant.
4	int end (groupe int) 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.
5	booléen find () Tente de trouver la sous-séquence suivante de la séquence d'entrée qui correspond au modèle.
6	recherche booléenne (début int) 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é.
sept	Groupe de chaînes () Renvoie la sous-séquence d'entrée capturée par le groupe donné lors de l'opération de correspondance précédente.
8	Groupe de chaînes (nom de chaîne) Renvoie la sous-séquence d'entrée capturée par le groupe de capture nommé donné lors de l'opération de correspondance précédente.
9	int groupCount () Renvoie le nombre de groupes de capture dans le modèle de ce matcher.
dix	booléen hasAnchoringBounds () Interroge l'ancrage des limites de région pour ce matcher.
11	booléen hasTransparentBounds () Interroge la transparence des limites de région pour ce matcher.
12	booléen hitEnd () Renvoie true si la fin de l'entrée a été atteinte par le moteur de recherche lors de la dernière opération de correspondance effectuée par ce matcher.
13	recherche booléenneAt () Tente de faire correspondre la séquence d'entrée, en commençant au début de la région, avec le modèle.
14	correspondances booléennes () Tente de faire correspondre toute la région au modèle.
15	Motif de motif () Renvoie le modèle interprété par ce matcher.
16	static String quoteReplacement (String s) Renvoie une chaîne de remplacement littérale pour la chaîne spécifiée.
17	Région de correspondance (début int, fin int) Définit les limites de la région de ce matcher.
18	int regionEnd () Signale l'index de fin (exclusif) de la région de ce matcher.
19	int regionStart () Signale l'index de début de la région de ce matcher.
20	String 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.
21	String 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.
22	booléen requireEnd () Renvoie true si plus d'entrée peut changer une correspondance positive en une correspondance négative.
23	Réinitialisation du matcher () Réinitialise ce matcher.
24	Réinitialisation du matcher (entrée CharSequence) Réinitialise ce matcher avec une nouvelle séquence d'entrée.
25	int début () Renvoie l'index de début de la correspondance précédente.
26	int start (groupe int) 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.
27	MatchResult toMatchResult () Renvoie l'état de correspondance de ce matcher sous forme de MatchResult.
28	Chaîne toString () Renvoie la représentation sous forme de chaîne de ce matcher.
29	Matcher useAnchoringBounds (booléen b) Définit l'ancrage des limites de région pour ce matcher.
30	Matcher usePattern (Pattern newPattern) Modifie le modèle utilisé par ce Matcher pour rechercher des correspondances.
31	Matcher useTransparentBounds (booléen) Définit la transparence des limites de région pour ce correcteur.

Méthodes héritées

Cette classe hérite des méthodes des classes suivantes -

• Java.lang.Object

introduction

le java.util.regex.PatternSyntaxException class représente une exception non vérifiée lancée pour indiquer une erreur de syntaxe dans un modèle d'expression régulière.

Déclaration de classe

Voici la déclaration pour java.util.regex.PatternSyntaxException classe -

public class PatternSyntaxException
   extends IllegalArgumentException

Constructeurs

Sr.Non	Méthode et description
1	PatternSyntaxException(String desc, String regex, int index) Construit une nouvelle instance de cette classe.

Méthodes de classe

Sr.Non	Méthode et description
1	String getDescription() Récupère la description de l'erreur.
2	int getIndex() Récupère l'index d'erreur.
3	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.
4	String getPattern() Récupère le modèle d'expression régulière erroné.

Méthodes héritées

Cette classe hérite des méthodes des classes suivantes -

• Java.lang.Throwable
• Java.lang.Object

Exemple

L'exemple suivant montre l'utilisation des méthodes de classe java.util.regex.Pattern.PatternSyntaxException.

package com.tutorialspoint;

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

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

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);
         
         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT); 
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

Compilons et exécutons le programme ci-dessus, cela produira le résultat suivant -

PatternSyntaxException: 
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

Voici divers exemples de correspondance de caractères à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	X Le caractère x
2	\\ Le caractère backslash
3	\ 0n Le caractère de valeur octale 0n (0 ≤ n ≤ 7)
4	\ 0nn Le caractère de valeur octale 0nn (0 ≤ n ≤ 7)
5	\ 0mnn Le caractère de valeur octale 0mnn (0 ≤ m ≤ 3, 0 ≤ n ≤ 7)
6	\ xhh Le caractère avec la valeur hexadécimale 0xhh
sept	\ uhhhh Le caractère avec la valeur hexadécimale 0xhhhh
8	\ t Le caractère de tabulation ('\ u0009')
9	\ n Le caractère de retour à la ligne (saut de ligne) ('\ u000A')
dix	\ r Le caractère de retour chariot ('\ u000D')
11	\F Le caractère de saut de page ('\ u000C')

Voici divers exemples de classes de caractères correspondantes à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	[abc] a, b ou c (classe simple).
2	[^ abc] Tout caractère sauf a, b ou c (négation).
3	[a-zA-Z] de a à z ou de A à Z, inclus (intervalle).
4	[annonce [mp]] a à d, ou m à p: [a-dm-p] (union).
5	[az && [def]] d, e ou f (intersection).
6	[az && [^ bc]] a à z, sauf pour b et c: [ad-z] (soustraction)
sept	[az && [^ mp]] a à z, et non m à p: [a-lq-z] (soustraction).

Voici divers exemples de correspondance de classes de caractères prédéfinies à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	. N'importe quel caractère (peut ou non correspondre aux terminateurs de ligne).
2	\ré Un chiffre: [0-9].
3	\RÉ Un non-chiffre: [^ 0-9].
4	\ s Un caractère d'espacement: [\ t \ n \ x0B \ f \ r]
5	\ S Un caractère non blanc: [^ \ s].
6	\ w Un caractère de mot: [a-zA-Z_0-9].
sept	\ W Un caractère autre qu'un mot: [^ \ w]

Vous trouverez ci-dessous divers exemples de correspondance des classes de caractères POSIX à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	\laboureur} Un caractère alphabétique minuscule: [az].
2	\ p {Supérieur} Un caractère alphabétique majuscule: [AZ].
3	\ p {ASCII} Tout ASCII: [\ x00- \ x7F].
4	\ p {Alpha} Un caractère alphabétique: [\ p {Lower} \ p {Upper}].
5	\ p {Chiffre} Un chiffre décimal: [0-9].
6	\ p {Alnum} Un caractère alphanumérique: [\ p {Alpha} \ p {Chiffre}].
sept	\ p {Ponctuel} Ponctuation: l'un des! "# $% & '() * +, -. / :; <=>? @ [\] ^ _> {|} <.
8	\ p {Graphique} Un caractère visible: [\ p {Alnum} \ p {Punct}].
9	\ p {Imprimer} Un caractère imprimable: [\ p {Graph} \ x20].
dix	\ p {Vide} Un espace ou une tabulation: [\ t].
11	\ p {XDigit} Un chiffre hexadécimal: [0-9a-fA-F].
12	\ p {Espace} Un caractère d'espacement: [\ t \ n \ x0B \ f \ r].

Voici divers exemples de correspondance des classes de caractères JAVA à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	\ p {javaLowerCase} Équivalent à java.lang.Character.isLowerCase ().
2	\ p {javaUpperCase} Équivalent à java.lang.Character.isUpperCase ().
3	\ p {javaWhitespace} Équivalent à java.lang.Character.isWhitespace ().
4	\ p {javaMirrored} Équivalent à java.lang.Character.isMirrored ().

Voici divers exemples de correspondance des classes de caractères Unicode à l'aide d'une expression régulière en java.

Sr.Non	Construire et matchs
1	\ p {IsLatin} Un caractère d'écriture latine.
2	\ p {InGreek} Un personnage dans le bloc grec.
3	\ p {Lu} Une lettre majuscule.
4	\ p {IsAlphabétique} Un caractère alphabétique (propriété binaire).
5	\ p {Sc} Un symbole monétaire.
6	\ P {InGreek} Tout caractère sauf un dans le bloc grec.
sept	[\ p {L} && [^ \ p {Lu}]] N'importe quelle lettre sauf une lettre majuscule.

Voici divers exemples de Boundary Matchers utilisant l'expression régulière en java.

Sr.Non	Construire et matchs
1	^ Le début d'une ligne.
2	$ La fin d'une ligne.
3	\ b Une limite de mot.
4	\ B Une frontière sans mot.
5	\UNE Le début de l'entrée.
6	\G La fin du match précédent.
sept	\ Z La fin de l'entrée mais pour le terminateur final, le cas échéant.
8	\ z La fin de l'entrée.

Un quantificateur gourmand indique au moteur de recherche de rechercher la chaîne entière et de vérifier si elle correspond à l'expression rationnelle donnée. Voici divers exemples de quantificateurs gourmands utilisant l'expression régulière en java.

Sr.Non	Construire et matchs
1	X? X, une fois ou pas du tout.
2	X* X, zéro fois ou plus
3	X + X, une ou plusieurs fois.
4	X {n} X, exactement n fois.
5	X {n,} X, au moins n fois.
6	X {n, m} X, au moins n mais pas plus de m fois

Un quantificateur réticent indique au moteur de recherche de commencer avec le morceau le plus court possible de la chaîne. Une fois la correspondance trouvée, le moteur continue; sinon, il ajoute un caractère à la section de la chaîne en cours de vérification et recherche cela, et ainsi de suite. Ce processus suit jusqu'à ce qu'il trouve une correspondance ou que la chaîne entière soit épuisée. Voici divers exemples de quantificateurs réticents utilisant une expression régulière en java.

Sr.Non	Construire et matchs
1	X?? X, une fois ou pas du tout.
2	X*? X, zéro fois ou plus
3	X +? X, une ou plusieurs fois.
4	X {n}? X, exactement n fois.
5	X {n,}? X, au moins n fois.
6	X {n, m}? X, au moins n mais pas plus de m fois

Un quantificateur possessif est similaire à un quantificateur gourmand. Il indique au moteur de démarrer en vérifiant la chaîne entière. Il en va différemment s'il ne fonctionne pas, si la correspondance échoue et qu'il n'y a pas de retour en arrière. Voici divers exemples de quantificateurs possessifs utilisant une expression régulière en java.

Sr.Non	Construire et matchs
1	X? + X, une fois ou pas du tout.
2	X * + X, zéro fois ou plus
3	X ++ X, une ou plusieurs fois.
4	X {n} + X, exactement n fois.
5	X {n,} + X, au moins n fois.
6	X {n, m} + X, au moins n mais pas plus de m fois

Voici divers exemples d'opérateurs logiques utilisant une expression régulière en java.

Sr.Non	Construire et matchs
1	XY X suivi de Y.
2	X | Y Soit X soit Y.

Impression