Expressions régulières Java
Les expressions régulières définissent des motifs pour les chaînes de caractères.
Les expressions régulières peuvent être utilisées pour rechercher, modifier ou traiter du texte.
Les expressions régulières ne sont pas limitées à un langage particulier, mais il existe des différences subtiles dans chaque langage.
Java fournit le package java.util.regex, qui contient les classes Pattern et Matcher pour gérer les opérations de correspondance d'expressions régulières.
Exemples d'expressions régulières
Une chaîne est en fait une expression régulière simple. Par exemple,Hello WorldL'expression régulière correspond à la chaîne "Hello World".
.(point) est aussi une expression régulière. Il correspond à n'importe quel caractère unique, comme "a" ou "1".
Le tableau suivant répertorie quelques exemples et descriptions d'expressions régulières :
| Expression régulière | Description |
|---|---|
this is text |
Correspond à la chaîne "this is text" |
this\s+is\s+text |
Notez les ... dans la chaîne\s+。 Correspond aux ... après le mot "this"\s+Il peut correspondre à plusieurs espaces, puis correspondre à la chaîne is, et ensuite\s+correspondre à plusieurs espaces puis être suivi de la chaîne text. Il peut correspondre à cet exemple : this is text |
^\d+(\.\d+)? |
^ définit le début \d+ correspond à un ou plusieurs chiffres ? définit l'option entre parenthèses comme facultative \. correspond à "." Exemples pouvant être mis en correspondance : "5", "1.5" et "2.21". |
Pour plus de contenu sur les expressions régulières, vous pouvez consulter :Expressions régulières - Tutoriel
Paquetage java.util.regex
java.util.regexLe paquetage est un paquetage de la bibliothèque standard Java utilisé pour prendre en charge les opérations sur les expressions régulières.
Le paquetage java.util.regex comprend principalement les trois classes suivantes :
-
Classe Pattern：
Un objet Pattern est une représentation compilée d'une expression régulière. La classe Pattern n'a pas de constructeur public. Pour créer un objet Pattern, vous devez d'abord appeler sa méthode statique publique compile, qui renvoie un objet Pattern. Cette méthode accepte une expression régulière comme premier argument.
-
Classe Matcher：
Un objet Matcher est le moteur qui interprète et effectue des opérations de correspondance sur une chaîne d'entrée. Comme la classe Pattern, Matcher n'a pas non plus de constructeur public. Vous devez appeler la méthode matcher d'un objet Pattern pour obtenir un objet Matcher.
-
PatternSyntaxException：
PatternSyntaxException est une classe d'exception non vérifiée qui indique une erreur de syntaxe dans un motif d'expression régulière.
L'exemple suivant utilise une expression régulière.*example.*pour déterminer si la chaîne contientexamplela sous-chaîne :
Exemple
La sortie de l'exemple est :
Groupes de capture
Les groupes de capture permettent de traiter plusieurs caractères comme une seule unité. Ils sont créés en regroupant les caractères entre parenthèses.
Par exemple, l'expression régulière (dog) crée un seul groupe contenant "d", "o" et "g".
Les groupes de capture sont numérotés en comptant leurs parenthèses ouvrantes de gauche à droite. Par exemple, dans l'expression ((A)(B(C))), il y a quatre groupes de ce type :
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
Vous pouvez utiliser la méthode groupCount d'un objet matcher pour voir combien de groupes l'expression possède. La méthode groupCount renvoie une valeur int indiquant combien de groupes de capture l'objet matcher possède actuellement.
Il existe également un groupe spécial (group(0)) qui représente toujours l'expression entière. Ce groupe n'est pas inclus dans la valeur de retour de groupCount.
Exemple
L'exemple suivant illustre comment trouver des chaînes de chiffres à partir d'une chaîne donnée :
Code du fichier RegexMatches.java :
L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :
Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT Found value: 3000 Found value: ! OK?
Syntaxe des expressions régulières
Dans d'autres langages,\\cela signifie :Je veux insérer une barre oblique inversée ordinaire (littérale) dans l'expression régulière ; veuillez ne pas lui donner de signification spéciale.
En Java,\\cela signifie :Je veux insérer une barre oblique inversée d'expression régulière, de sorte que le caractère qui la suit ait une signification spéciale.
Par conséquent, dans d'autres langages (comme Perl), une seule barre oblique inversée\suffit à produire un effet d'échappement, tandis que dans les expressions régulières Java, deux barres obliques inversées sont nécessaires pour être interprétées comme l'effet d'échappement dans d'autres langages. On peut aussi simplement comprendre que dans les expressions régulières Java, deux\\représentent une dans d'autres langages\, c'est pourquoi l'expression régulière pour un chiffre unique est\\d, et une barre oblique inversée normale est représentée par\\。
System.out.print("\\"); // 输出为 \
System.out.print("\\\\"); // 输出为 \\
Caractère | Description |
|---|---|
\ | Marque le caractère suivant comme un caractère spécial, un littéral, une rétroréférence, ou un échappement octal. Par exemple,ncorrespond au caractèren。\ncorrespond à un saut de ligne. La séquence\\\\correspond\\ ，\\(correspond(。 |
^ | Correspond à la position au début de la chaîne d'entrée. Si, dans l'objetRegExp, la propriétéMultilineest définie, ^ correspondra également à la position après "\n" ou "\r". |
$ | Correspond à la position à la fin de la chaîne d'entrée. Si l'objetRegExpa la propriétéMultilinedéfinie, $ correspondra aussi à la position avant "\n" ou "\r". |
* | Correspond au caractère ou à la sous-expression précédent(e) zéro ou plusieurs fois. Par exemple, zo* correspond à "z" et "zoo". * est équivalent à {0,}. |
+ | Correspond au caractère ou à la sous-expression précédent(e) une ou plusieurs fois. Par exemple, "zo+" correspond à "zo" et "zoo", mais ne correspond pas à "z". + est équivalent à {1,}. |
? | Correspond au caractère ou à la sous-expression précédent(e) zéro ou une fois. Par exemple, "do(es)?" correspond à "do" ou au "do" dans "does". ? est équivalent à {0,1}. |
{n} | n est un entier non négatif. Correspond exactementnfois. Par exemple, "o{2}" ne correspond pas au "o" dans "Bob", mais correspond aux deux "o" dans "food". |
{n,} | n est un entier non négatif. Correspond au moinsn fois. Par exemple, « o{2,} » ne correspond pas au « o » dans « Bob », mais correspond à tous les « o » dans « foooood ». « o{1,} » est équivalent à « o+ ». « o{0,} » est équivalent à « o* ». |
{n,m} | metnsont des entiers non négatifs, oùn <= m. Correspond au moinsnfois, au plusmfois. Par exemple, « o{1,3} » correspond aux trois premiers « o » dans « fooooood ». 'o{0,1}' est équivalent à 'o?'. Remarque : vous ne pouvez pas insérer d'espaces entre la virgule et les chiffres. |
? | Lorsque ce caractère suit immédiatement un autre quantificateur (*, +, ?, {n}、{n,}、{n,m}), le mode de correspondance est « non-greedy ». Un mode « non-greedy » correspond à la chaîne la plus courte possible recherchée, tandis que le mode « greedy » par défaut correspond à la chaîne la plus longue possible recherchée. Par exemple, dans la chaîne « oooo », « o+? » correspond à un seul « o », tandis que « o+ » correspond à tous les « o ». |
. | Correspond à un seul caractère, sauf « \r\n ». Pour correspondre à n'importe quel caractère, y compris « \r\n », utilisez un modèle tel que « [\s\S] ». |
(pattern) | Correspond aumodèleet capture la sous-expression correspondante. Vous pouvez utiliser$0…$9la propriété pour récupérer la correspondance capturée à partir de la collection « match » résultante. Pour correspondre au caractère de parenthèse ( ), utilisez « \( » ou « \) ». |
(?:pattern) | Correspond àmodèleMais une sous-expression qui ne capture pas la correspondance, c.-à-d. qu'il s'agit d'une correspondance sans capture et ne stocke pas la correspondance pour une utilisation ultérieure. Cela est utile lors de la combinaison de parties de modèle avec le caractère "ou" (|). Par exemple, 'industr(?:y|ies)' est une expression plus économique que 'industry|industries'. |
(?=pattern) | Une sous-expression qui effectue une recherche d'anticipation positive, qui correspond aumodèleà la chaîne au point de départ de la chaîne correspondante. Il s'agit d'une correspondance sans capture, c.-à-d. qu'elle ne peut pas capturer la correspondance pour une utilisation ultérieure. Par exemple, 'Windows (?=95|98|NT|2000)' correspond à "Windows" dans "Windows 2000", mais ne correspond pas à "Windows" dans "Windows 3.1". L'anticipation ne consomme pas de caractères ; c'est-à-dire qu'après qu'une correspondance se produit, la recherche de la correspondance suivante commence immédiatement après la correspondance précédente, et non après les caractères qui composent l'anticipation. |
(?!pattern) | Une sous-expression qui effectue une recherche d'anticipation négative, qui correspond à une chaîne qui ne se trouve pas au point de départ d'une chaîne de recherche correspondant à unmodèle. Il s'agit d'une correspondance sans capture, c.-à-d. qu'elle ne peut pas capturer la correspondance pour une utilisation ultérieure. Par exemple, 'Windows (?!95|98|NT|2000)' correspond à "Windows" dans "Windows 3.1", mais ne correspond pas à "Windows" dans "Windows 2000". L'anticipation ne consomme pas de caractères ; c'est-à-dire qu'après qu'une correspondance se produit, la recherche de la correspondance suivante commence immédiatement après la correspondance précédente, et non après les caractères qui composent l'anticipation. |
x|y | Correspond àxouy. Par exemple, 'z|food' correspond à "z" ou "food". '(z|f)ood' correspond à "zood" ou "food". |
[xyz] | Jeu de caractères. Correspond à tout caractère inclus. Par exemple, "[abc]" correspond à "a" dans "plain". |
[^xyz] | Jeu de caractères négatif. Correspond à tout caractère non inclus. Par exemple, "[^abc]" correspond à "p", "l", "i", "n" dans "plain". |
[a-z] | Plage de caractères. Correspond à tout caractère dans la plage spécifiée. Par exemple, "[a-z]" correspond à toute lettre minuscule dans la plage "a" à "z". |
[^a-z] | Caractère de plage négative. Correspond à tout caractère ne figurant pas dans la plage spécifiée. Par exemple, "[^a-z]" correspond à tout caractère ne faisant pas partie de la plage "a" à "z". |
\b | Correspond à une limite de mot, c'est-à-dire la position entre un mot et un espace. Par exemple, "er\b" correspond à "er" dans "never", mais ne correspond pas à "er" dans "verb". |
\B | Correspondance de non-limite de mot. "er\B" correspond à "er" dans "verb", mais ne correspond pas à "er" dans "never". |
\cx | Correspond auxcaractère de contrôle indiqué. Par exemple, \cM correspond à Control-M ou au retour chariot.xLa valeur doit être comprise entre A-Z ou a-z. Sinon, c est supposé être le caractère "c" lui-même. |
\d | Correspondance de chiffre. Équivalent à [0-9]. |
\D | Correspondance de caractère non numérique. Équivalent à [^0-9]. |
\f | Correspondance de caractère de saut de page. Équivalent à \x0c et \cL. |
\n | Correspondance de caractère de nouvelle ligne. Équivalent à \x0a et \cJ. |
\r | Correspond à un retour chariot. Équivalent à \x0d et \cM. |
\s | Correspond à tout caractère d'espacement, y compris l'espace, la tabulation, le saut de page, etc. Équivalent à [ \f\n\r\t\v]. |
\S | Correspond à tout caractère qui n'est pas un caractère d'espacement. Équivalent à [^ \f\n\r\t\v]. |
\t | Correspondance de caractère de tabulation. Équivalent à \x09 et \cI. |
\v | Correspond au caractère de tabulation verticale. Équivalent à \x0b et \cK. |
\w | Correspond à tout caractère de mot, y compris le tiret bas. Équivalent à "[A-Za-z0-9_]". |
\W | Correspond à tout caractère qui n'est pas un caractère de mot. Équivalent à "[^A-Za-z0-9_]". |
\xn | Correspond àn, où lenest un code d'échappement hexadécimal. Le code d'échappement hexadécimal doit comporter exactement deux chiffres. Par exemple, "\x41" correspond à "A". "\x041" est équivalent à "\x04"&"1". Les codes ASCII sont autorisés dans les expressions régulières. |
\num | Correspond ànum, où lenumest un entier positif. Une référence arrière vers une correspondance capturée. Par exemple, "(.)\1" correspond à deux caractères identiques consécutifs. |
\n | Identifie un code d'échappement octal ou une référence arrière. Si \nest précédé par au moinsnsous-expressions capturantes, alorsnest une référence arrière. Sinon, sinest un chiffre octal (0-7), alorsnest un code d'échappement octal. |
\nm | Identifie un code d'échappement octal ou une rétro-référence. Si \nmest précédé d'au moinsnmsous-expressions capturantes, alorsnmest une rétro-référence. Si \nmest précédé d'au moinsncaptures, alorsnest une rétro-référence, suivie du caractèrem. Si aucun des cas précédents n'existe, alors \nmcorrespond à la valeur octalenm, oùn etmest un chiffre octal (0-7). |
\nml | Lorsquenest un chiffre octal (0-3),metllorsqu'il est un chiffre octal (0-7), correspond au code d'échappement octalnml。 |
\un | Correspond àn, oùnest un caractère Unicode représenté par un nombre hexadécimal à quatre chiffres. Par exemple, \u00A9 correspond au symbole de copyright (©). |
Selon les exigences de la spécification du langage Java, les barres obliques inverses dans les chaînes du code source Java sont interprétées comme des échappements Unicode ou d'autres échappements de caractères. Par conséquent, deux barres obliques inverses doivent être utilisées dans les littéraux de chaîne pour protéger l'expression régulière d'une interprétation par le compilateur de bytecode Java. Par exemple, lorsqu'il est interprété comme une expression régulière, le littéral de chaîne "\b" correspond à un seul caractère de retour arrière, tandis que "\\b" correspond à une limite de mot. Le littéral de chaîne "\(hello\)" est illégal et provoquera une erreur de compilation ; pour correspondre à la chaîne (hello), le littéral de chaîne "\\(hello\\)" doit être utilisé.
Méthodes de la classe Matcher
Méthodes d'index
Les méthodes d'index fournissent des valeurs d'index utiles qui indiquent précisément où une correspondance peut être trouvée dans la chaîne d'entrée :
| Non. | Méthode et description |
|---|---|
| 1 |
public int start() Renvoie l'index initial de la correspondance précédente. |
| 2 |
public int start(int group) Renvoie l'index initial 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 de recherche sont utilisées pour vérifier la chaîne d'entrée et renvoient une valeur booléenne indiquant si le motif est trouvé :
| Non. | Méthode et description |
|---|---|
| 1 |
public boolean lookingAt() Tente de faire correspondre la séquence d'entrée au motif, en commençant au début de la région. |
| 2 |
public boolean find() Tente de trouver la sous-séquence 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 sous-séquence suivante de la séquence d'entrée qui correspond au motif, en commençant à l'index spécifié. |
| 4 |
public boolean matches() Tente de faire correspondre toute la région au motif. |
Méthodes de remplacement
Les méthodes de remplacement sont des méthodes permettant de remplacer du texte dans la chaîne d’entrée :
| Non. | Méthode et description |
|---|---|
| 1 |
public Matcher appendReplacement(StringBuffer sb, String replacement) Implémente une étape non terminale d’ajout et de remplacement. |
| 2 |
public StringBuffer appendTail(StringBuffer sb) Implémente une étape terminale d’ajout et de remplacement. |
| 3 |
public String replaceAll(String replacement) Remplace chaque sous-séquence de la séquence d’entrée qui correspond au motif 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 motif par la chaîne de remplacement donnée. |
| 5 |
public static String quoteReplacement(String s) Renvoie la chaîne de remplacement littérale pour la chaîne spécifiée. Cette méthode renvoie une chaîne qui fonctionne comme s’il s’agissait d’une chaîne littérale passée à la méthode appendReplacement de la classe Matcher. |
Méthodes start et end
Ce qui suit est un exemple qui compte le nombre de fois où le mot "cat" apparaît dans la chaîne d'entrée :
Code du fichier RegexMatches.java :
L'exemple ci-dessus se compile et s'exécute avec 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
On peut 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 fournit également des informations utiles sur l'endroit où les correspondances se produisent dans la chaîne d'entrée.
La méthode start renvoie l'index initial 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 1.
Méthodes matches et lookingAt
Les méthodes matches et lookingAt sont toutes deux utilisées pour tenter de faire correspondre une séquence d'entrée à un motif. La différence est que matches exige que toute la séquence corresponde, alors que lookingAt non.
La méthode lookingAt ne nécessite pas que toute la chaîne corresponde, mais elle nécessite une correspondance à partir du premier caractère.
Ces deux méthodes sont souvent utilisées au début de la chaîne d'entrée.
Nous utilisons l'exemple suivant pour expliquer cette fonctionnalité :
Code du fichier RegexMatches.java :
L'exemple ci-dessus se compile et s'exécute avec le résultat suivant :
Current REGEX is: foo Current INPUT is: fooooooooooooooooo Current INPUT2 is: ooooofoooooooooooo lookingAt(): true matches(): false lookingAt(): false
Méthodes replaceFirst et replaceAll
Les méthodes replaceFirst et replaceAll sont utilisées pour remplacer le texte qui correspond à l'expression régulière. La différence est que replaceFirst remplace la première correspondance, tandis que replaceAll remplace toutes les correspondances.
L'exemple suivant explique cette fonctionnalité :
Code du fichier RegexMatches.java :
Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est :
The cat says meow. All cats say meow.
Méthodes appendReplacement et appendTail
La classe Matcher fournit également les méthodes appendReplacement et appendTail pour le remplacement de texte :
Voir l'exemple suivant pour expliquer cette fonctionnalité :
Code du fichier RegexMatches.java :
Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est :
-foo-foo-foo-kkk
Méthodes de la classe PatternSyntaxException
PatternSyntaxException est une classe d'exception non contrôlé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 nous aider à voir quelle erreur s'est produite.
| Non. | Méthode et description |
|---|---|
| 1 |
public String getDescription() Obtient la description de l'erreur. |
| 2 |
public int getIndex() Obtient l'index de l'erreur. |
| 3 |
public String getPattern() Obtient 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 motif d'expression régulière erroné, et une indication visuelle de l'index de l'erreur dans le motif. |