Expressions régulières Java

Marquez le caractère suivant comme caractère spécial, texte, référence arrière ou échappement octal. Par exemple, « n » correspond au caractère « n ». "n" correspond à un caractère de nouvelle ligne. La séquence "\" correspond à "", "(" correspond à "(".

^

correspond au caractères d'entrée La position où commence la chaîne. Si l'attribut Multiline de l'objet RegExp est défini, ^ correspondra également à la position après "n" ou "r". >

correspond à la fin de la chaîne d'entrée. Si la propriété Multiline de l'objet RegExp est définie, $ correspondra également à la position avant "n" ou "r".

*

correspond au caractère ou à la sous-expression précédent zéro ou plusieurs fois. Par exemple, zo* correspond à « z » et « zoo ». * Équivalent à {0,}.

+

correspond au caractère ou à la sous-expression précédent une ou plusieurs fois. Par exemple, « zo+ » correspond à « zo » et « zoo » mais pas à « z ». + Équivalent à {1,}.

?

correspond au caractère ou à la sous-expression précédent zéro ou une fois. Par exemple, « faire(s) ? » correspond à « faire » ou « faire » dans « fait ». ? Équivalent à {0,1}.

{n}

n est un non- entier négatif. Correspond exactement n fois. Par exemple, "o{2}" ne correspond pas au "o" dans "Bob", mais correspond aux deux "o" dans "food".

{n,}

n est un non -entier négatif. Faites correspondre au moins n fois. Par exemple, "o{2,}" ne correspond pas au "o" de "Bob" mais correspond à tous les o de "foooood". "o{1,}" équivaut à "o+". "o{0,}" équivaut à "o*".

{n,m}

M et n sont des entiers non négatifs, où n <= m. Faites correspondre au moins n fois et au plus m fois. Par exemple, "o{1,3}" correspond aux trois premiers o de "fooooood". « o{0,1} » est équivalent à « o ? ». Remarque : Vous ne pouvez pas insérer d'espaces entre les virgules et les chiffres.

?

Lorsque ce caractère est suivi de tout autre qualificatif (*, +, ?, {n}, {n,}, {n,m}), le motif correspondant est "non gourmand". Le modèle « non gourmand » correspond à la chaîne la plus courte possible recherchée, tandis que le modèle « gourmand » par défaut correspond à la chaîne la plus longue possible recherchée. Par exemple, dans la chaîne "oooo", "o+?" ne correspond qu'à un seul "o", tandis que "o+" correspond à tous les "o".

.

correspond à n'importe quel caractère sauf "rn". Pour faire correspondre n'importe quel caractère incluant "rn", utilisez un modèle tel que "[sS]".

(motif)

correspond au motif et capture cela La sous-expression correspondante. Les correspondances capturées peuvent être récupérées à partir de la collection "matches" résultante à l'aide de l'attribut $0…$9. Pour faire correspondre le caractère parenthèse ( ), utilisez "(" ou ")".

(?:motif)

correspond au modèle mais ne capture pas la sous-expression de cette correspondance, c'est-à-dire qu'il s'agit d'une correspondance sans capture et ne stocke pas la correspondance pour une utilisation ultérieure. Ceci est utile lors de la combinaison de parties de motif avec le caractère « ou » (|). Par exemple, 'industr(?:y|ies) est une expression plus économique que 'industry|industries'.

(?=modèle)

Sous-expression qui effectue une recherche anticipée avant Une expression qui correspond à une chaîne au début d'une chaîne correspondant au motif. Il s'agit d'une correspondance sans capture, c'est-à-dire une correspondance qui ne peut pas être capturée pour une utilisation ultérieure. Par exemple, « Windows (?=95|98|NT|2000) » correspond à « Windows » dans « Windows 2000 » mais pas à « Windows » dans « Windows 3.1 ». Les anticipations de prédiction n'occupent pas de caractères, c'est-à-dire qu'après qu'une correspondance se produit, la correspondance suivante est recherchée immédiatement après la correspondance précédente, et non après les caractères qui composent l'anticipation de prédiction.

(?!modèle)

Une sous-expression qui effectue une analyse anticipée inversée search Une expression qui correspond à une chaîne de recherche qui ne se trouve pas au début d'une chaîne correspondant au modèle. Il s'agit d'une correspondance sans capture, c'est-à-dire une correspondance qui ne peut pas être capturée pour une utilisation ultérieure. Par exemple, « Windows (?!95|98|NT|2000) » correspond à « Windows » dans « Windows 3.1 » mais pas à « Windows » dans « Windows 2000 ». Les anticipations de prédiction n'occupent pas de caractères, c'est-à-dire qu'après qu'une correspondance se produit, la correspondance suivante est recherchée immédiatement après la correspondance précédente, et non après les caractères qui composent l'anticipation de prédiction.

x|y

correspond à x ou y. Par exemple, « z|food » correspond à « z » ou « food ». '(z|f)ood' correspond à "zood" ou "food".

[xyz]

jeu de caractères. Correspond à n'importe quel caractère contenu dans . Par exemple, « [abc] » correspond au « a » dans « plain ».

[^xyz]

Jeu de caractères inversés. Correspond à tous les caractères non inclus. Par exemple, "[^abc]" correspond à "p", "l", "i" et "n" dans "plain".

[a-z]

plage de caractères. Correspond à n’importe quel caractère dans la plage spécifiée. Par exemple, "[a-z]" correspond à n'importe quelle lettre minuscule comprise entre "a" et "z".

[^a-z]

Caractère de plage inversée. Correspond à tout caractère ne se trouvant pas dans la plage spécifiée. Par exemple, "[^a-z]" correspond à tout caractère qui n'est pas compris entre "a" et "z".

b

correspond à une limite de mot, c'est-à-dire la position entre un mot et un espace. Par exemple, "erb" correspond au "er" dans "jamais", mais pas au "er" dans "verb".

B

correspondance de limites sans mots. "erB" correspond au "er" dans "verb", mais pas au "er" dans "jamais".

cx

correspond au caractère de contrôle indiqué par x. Par exemple, cM correspond à Control-M ou au retour chariot. La valeur de x doit être comprise entre A-Z ou a-z. Si ce n'est pas le cas, c est supposé être le caractère "c" lui-même.

d

Correspondance des caractères numériques. Équivalent à [0-9].

D

correspondance de caractères non numériques. Équivalent à [^0-9].

f

correspondance de flux de formulaire. Équivalent à x0c et cL.

n

correspondance de nouvelle ligne. Équivalent à x0a et cJ.

r

correspond à un caractère de retour chariot. Équivalent à x0d et cM.

s

correspond à n'importe quel caractère d'espacement, y compris les espaces, les tabulations, les sauts de formulaire, etc. Équivalent à [ fnrtv ].

S

correspond à tout caractère autre qu'un espace. Équivalent à [^ fnrtv].

t

correspondance des onglets. Équivalent à x09 et cI.

v

correspondance d'onglets verticaux. Équivalent à x0b et cK.

w

correspond à n'importe quel caractère de type mot, y compris le trait de soulignement. Équivalent à "[A-Za-z0-9_]".

W

correspond à n'importe quel caractère autre qu'un mot. Équivalent à "[^A-Za-z0-9_]".

xn

correspond à n, où n est un code d'échappement hexadécimal. Le code d’échappement hexadécimal doit comporter exactement deux chiffres. Par exemple, « x41 » correspond à « A ». "x041" équivaut à "x04" et "1". Autoriser les codes ASCII dans les expressions régulières.

num

correspond à num, où num est un entier positif. Backreference pour capturer la correspondance. 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 n est précédé d'au moins n capturant des sous-expressions, alors n est une référence arrière. Sinon, si n est un nombre octal (0-7), alors n est un code d'échappement octal.

nm

Identifie un code d'échappement octal ou une référence arrière. Si nm est précédé d'au moins nm capturant des sous-expressions, alors nm est une référence arrière. Si nm est précédé d'au moins n captures, alors n est une référence arrière suivie des caractères m. Si aucune des conditions précédentes n'existe, alors nm correspond à la valeur octale nm, où n et m sont des chiffres octaux (0 - 7).

nml

Quand n est un nombre octal ( 0 -3), lorsque m et l sont des nombres octaux (0-7), faites correspondre le code d'échappement octal nml.

un

correspond à n, où n est un caractère Unicode représenté sous la forme d'un nombre hexadécimal à quatre chiffres. Par exemple, u00A9 correspond au symbole de droit d'auteur (©).

Méthode de remplacement

La méthode de remplacement consiste à remplacer le texte dans la chaîne d'entrée :

Méthodes de début et de fin

Ce qui suit est un exemple de comptage du nombre de fois où le mot « chat » apparaît dans la chaîne d'entrée :

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); // 获取 matcher 对象
       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());
      }
   }
}

La compilation et l'exécution des résultats de ce qui précède L'exemple est le 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

Vous pouvez voir que cet exemple utilise des limites de mots 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ù la correspondance se produit 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 en ajoute un à l'index du dernier caractère correspondant.

Méthodes matches et LookingAt

Les méthodes matches et LookingAt sont toutes deux utilisées pour essayer de faire correspondre un modèle de séquence d'entrée. La différence entre eux est que matcher nécessite que la séquence entière corresponde, contrairement à LookingAt.

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 fonction :

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

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

méthodesreplaceFirst et replaceAll

replaceFirst et La méthode replaceAll est utilisée pour remplacer le texte correspondant à une expression régulière. La différence est que replaceFirst remplace la première correspondance et replaceAll remplace toutes les correspondances.

L'exemple suivant explique cette fonction :

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

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

The cat says meow. All cats say meow.

méthodes appendReplacement et appendTail

La classe Matcher fournit également Les méthodes appendReplacement et appendTail sont utilisées pour le remplacement de texte :

Regardez l'exemple suivant pour expliquer cette fonction :

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);
      // 获取 matcher 对象
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()){
         m.appendReplacement(sb,REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants suit :

-foo-foo-foo-

Méthodes de la classe PatternSyntaxException

PatternSyntaxException est une classe d'exception non forcé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 quelles erreurs se sont produites.

Site Web PHP chinois

MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger