Expressions régulières en Java

Une expression régulière est une sorte de modèle qui peut être appliqué au texte (String, en Java). Java fournit le package java.util.regex pour faire correspondre les expressions régulières. Les expressions régulières sont très similaires au langage de programmation Perl et sont très faciles à apprendre. Une expression régulière correspond au texte (une partie de celui-ci) ou non. * Si une expression régulière correspond à un morceau de texte, alors nous pouvons le trouver. ** Si l'expression régulière est composée, nous pouvons alors facilement déterminer quelle partie de l'expression régulière correspond à quelle partie du texte.

Premier exemple

L'expression régulière " [a-z] +" correspond à toutes les lettres minuscules du texte. [a-z]désigne n'importe quel caractère de aà zinclusif et +signifie « un ou plusieurs » caractères. Supposons que nous fournissions la chaîne « Code 2 Learn Java Tutoriel ». Comment faire cela en Java Tout d'abord, vous devez créer un modèle :

import java.util.regex.*;
Pattern p = Pattern.compile(“[a-z]+”);

Ensuite vous devez créer matcherpour le texte en envoyant un message sur le schéma :

Matcher m = p.matcher(“code 2 learn java tutorial”);

REMARQUE : les constructeurs non plus Pattern, Matchernous les créons à l'aide de méthodes de classe Pattern. Pattern Class:L'objet de classe constitue une représentation 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'une des méthodes statiques publiques, qui renvoie ensuite un objet de la classe Pattern. Ces méthodes prennent une expression régulière comme argument. Matcher Class:L'objet Finder est un moteur qui interprète le modèle et effectue des opérations de correspondance sur la chaîne d'entrée. Comme Patternune classe, Matcherelle n’a pas de constructeur public. Vous obtenez un objet Matcheren appelant une méthode matchersur un objet de classe Pattern. Une fois que nous avons terminé ces étapes, et que nous avons maintenant une instance de la classe Matcher m , nous pouvons maintenant vérifier si le modèle a été trouvé ou non, et si oui, à quelle position, etc. m.matches()renvoie true si le modèle correspond à la chaîne entière, false sinon. m.lookingAt()renvoie true si le modèle correspond au début de la chaîne, false sinon. m.find ()renvoie vrai si le modèle correspond à une partie du texte.

Trouver une correspondance

Après une correspondance réussie, m.start() renverra l'index du premier caractère correspondant et m.end() renverra l'index du dernier caractère correspondant, plus un. Si une tentative infructueuse a été faite et qu'aucune correspondance n'a été trouvée, m.start()ils m.end()lancerontIllegalStateException

• C'est RuntimeExceptionpour que vous n'ayez pas à l'attraper.

Cela peut sembler étrange de m.end()renvoyer l'index du dernier caractère correspondant plus un, mais c'est exactement ce que font la plupart des String.

• Par exemple,“Now is the time“.substring(m.start(), m.end())

renverra la même chaîne. Jetons un coup d'œil au code :

import java.util.regex.*;

public class RegexTest {
    public static void main(String args[]) {
        String pattern = "[a-z]+";
        String text = "code 2 learn java tutorial";
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(text);
        while(m.find()) {
            System.out.print(text.substring(m.start(), m.end()) + "*");
        }
    }
}

Output: code*learn*java*tutorial*

Méthodes supplémentaires

S'il y a une correspondance, alors :

• m.replaceFirst(replacement)renvoie une nouvelle chaîne, où la première sous-chaîne qui correspond au modèle sera remplacée parreplacement
• m.replaceAll(replacement)renvoie une nouvelle chaîne, où chaque sous-chaîne correspondant au modèle sera remplacée
• m.find(StartIndex)trouver la prochaine correspondance à partir de l'index spécifié
• m.reset()réinitialise le modèle
• m.reset(NewText)réinitialise le chercheur et lui donne un nouveau texte (peut-être String, StringBufferou CharBuffer)

Syntaxe des expressions régulières

• ^Correspond au début d'une ligne.
• $Correspond à la fin de la chaîne.
• .Correspond à n'importe quel caractère, à l'exception du saut de ligne. L'utilisation de l'option m lui permet de correspondre à une nouvelle ligne.
• [...]Correspond à n’importe quel caractère entre parenthèses.
• [^ ...]Correspond à n’importe quel caractère non entre parenthèses.
• \ACommencez toute la ligne.
• \zFin de toute la ligne.
• \ZLa fin de la ligne entière, à l'exception du terminateur de ligne final.
• re*Correspond à 0 ou plusieurs occurrences de l'expression précédente.
• re+Une ou plusieurs correspondances de l'expression précédente.
• re?Correspond à 0 ou 1 à l'emplacement de l'expression précédente.
• re{n}Correspond exactement à N Nombre 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|bCorrespond à a ou b.
• (re)Un groupe d'expressions régulières et mémorisant le texte trouvé.
• (?: re)Groupes d'expressions régulières qui ne se souviennent pas du texte trouvé.
• (?> re)Correspond à un modèle indépendant sans retour.
• \wCorrespond aux lettres et aux chiffres [a-zA-Z_0-9].
• \WCe ne sont ni des lettres ni des chiffres.
• \sCorrespond aux espaces. Équivalent à [\t\n\r\f].
• \SPas de caractères d'espacement.
• \dCorrespond aux chiffres. Équivalent à [0-9].
• \DNe correspond pas aux chiffres.
• \GCorrespond au point du dernier match.
• \nCorrespond à la nouvelle ligne.
• \bCorrespond à une limite de mot.
• \BNe correspond pas à une limite de mot.
• \n, \t, etc.Caractères de nouvelle ligne, de retour chariot, de tabulation, etc.
• \QCitez tous les caractères avant \E.
• \ELa citation commençant par \Q se termine.