Préface
Cet article présentera la classe de modèle et la classe Matcher dans les expressions régulières de Java. Tout d'abord, nous devons comprendre clairement que l'expression régulière spécifiée en tant que chaîne doit d'abord être compilée comme une instance de la classe de modèle. Par conséquent, comment mieux comprendre ces deux classes est quelque chose que les programmeurs doivent savoir.
Jetons un coup d'œil à ces deux catégories:
1. Le concept de capture de groupe
Le groupe de capture peut être numéroté en calculant ses supports ouverts de gauche à droite, qui commence par 1. Par exemple, dans l'expression ((a) (b (c))), il y a quatre de ces groupes:
1 ((a) (b (c))) 2 (a) 3 (b (c)) 4 (c)
Le groupe Zeros représente toujours toute l'expression. Les groupes commençant par (?) Sont des groupes purs non-capture qui ne capturent pas le texte et ne comptent pas contre les comptages combinés.
L'entrée de capture associée à un groupe est toujours la sous-séquence qui correspond le plus récemment au groupe. Si le groupe est à nouveau calculé en raison de la quantification, sa valeur précédemment capturée sera conservée lors de la deuxième panne de calcul (le cas échéant). Par exemple, la correspondance de la chaîne "ABA" à l'expression (a (b)?) + Va définir le deuxième groupe sur "b". Au début de chaque match, toutes les entrées capturées sont jetées.
2. Explication détaillée des classes de motifs et de correspondance
Les expressions régulières Java sont implémentées via la classe de modèle et la classe Matcher sous le package java.util.regex (il est recommandé d'ouvrir le document de l'API Java lors de la lecture de cet article. Lors de l'introduction de la méthode introduite, vérifiez la description de la méthode dans l'API Java, et l'effet sera meilleur).
La classe de modèle est utilisée pour créer une expression régulière, ou on peut dire qu'il créait un motif de correspondance. Son constructeur est privé et ne peut pas être créé directement, mais il peut créer une expression régulière via la méthode simple d'usine de Pattern.complie(String regex)
Exemple de code Java:
Pattern p = motive.compile ("// w +"); p.Pattern (); // return / w + pattern() Renvoie la forme de chaîne d'une expression régulière, qui est en fait le paramètre regex de Pattern.complile(String regex)
1.Pattern.split (entrée de charon
Le motif a une méthode split(CharSequence input) , qui est utilisée pour séparer les chaînes et renvoie une chaîne []. Je suppose que String.split(String regex) est implémenté via Pattern.split(CharSequence input) .
Exemple de code Java:
Pattern p = motive.compile ("// d +"); String [] str = p.split ("Mon QQ est: 456456 Mon téléphone est: 0532214 Mon e-mail est: [email protected]");Résultat: str [0] = "Mon qq est:" Str [1] = "Mon téléphone est:" Str [2] = "Mon e-mail est: [email protected]"
2. Pattern.matcher (String Regex, CharSequence Entrée) est une méthode statique utilisée pour faire correspondre rapidement les chaînes. Cette méthode convient à la correspondance d'une seule fois et à la correspondance de toutes les chaînes.
Exemple de code Java:
Pattern.matches ("// d +", "2223"); // retourne true pattern.matches ("// d +", "2223aa"); // return false, toutes les chaînes doivent être appariées pour retourner true, ici ne peut pas correspondre3.Pattern.matcher (entrée CharSequence)
Après avoir dit tellement de choses, c'est enfin le tour de la classe du Matcher à ses débuts. Pattern.matcher(CharSequence input) renvoie un objet de correspondance.
La méthode du constructeur de la classe Matcher est également privée et ne peut pas être créée à volonté. Il ne peut obtenir que des instances de cette classe via Pattern.matcher(CharSequence input) .
La classe de modèle ne peut effectuer que des opérations de correspondance simples. Afin d'obtenir des opérations de correspondance régulières plus fortes et plus pratiques, il est nécessaire de coopérer avec le modèle et le correspondant. La classe de matchur fournit un support de regroupement pour les expressions régulières et le support de correspondance multiple pour les expressions régulières.
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher m = p.matcher ("22BB23"); m.pattern (); // return p c'est pour retourner quel objet de modèle a été créé par l'objet Matcher.4.matcher.matches () / Matcher.lookingat () / Matcher.Find ()
La classe de matchur fournit trois méthodes d'opération de correspondance. Les trois méthodes renvoient le type booléen. Retour vrai lorsque le match est atteint. S'il n'y a pas de correspondance, il revient faux.
matches() correspond à la chaîne entière et ne renvoie pas vrai uniquement si la chaîne entière correspond
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher m = p.matcher ("22BB23"); m.matches (); // renvoie false, car BB ne peut pas être apparié par / d +, ce qui entraîne la correspondance de la chaîne entière infructueuse. Matcher m2 = p.matcher ("2223"); m2.matches (); // renvoie true, car / d + correspond à la chaîne entière Regardons en arrière sur Pattern.matcher(String regex,CharSequence input) , ce qui équivaut au code suivant
Pattern.compile(regex).matcher(input).matches()
lookingAt() correspond à la chaîne précédente et ne renvoie que si la chaîne correspondante est à l'avant.
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher m = p.matcher ("22BB23"); M.Lookingat (); // Renvoie True, car / d + correspond aux 22 correspondants précédents m2 = p.matcher ("aa2223"); m2.lookingat (); // return false, car / d + ne peut pas correspondre au AA précédent find() correspond à la chaîne et la chaîne correspondante peut être n'importe où.
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher m = p.matcher ("22BB23"); m.find (); // renvoie le véritable matchur m2 = p.matcher ("aa2223"); m2.find (); // renvoie le véritable matchur m3 = p.matcher ("aa2223bb"); M3.Find (); // Renvoie True Matcher M4 = P.Matcher ("AABB"); m4.find (); // retourne false5.mathcer.start () / matcher.end () / matcher.group ()
Après avoir utilisé matches() , lookingAt() et find() pour effectuer des opérations de correspondance, vous pouvez utiliser les trois méthodes ci-dessus pour obtenir des informations plus détaillées.
start() Renvoie la position d'index de la sous-chaîne correspondante dans la chaîne.
end() renvoie la position d'index du dernier caractère de la sous-chaîne correspondante dans la chaîne.
group() renvoie la sous-chaîne correspondante
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher m = p.matcher ("aaa2223bb"); m.find (); // correspond à 2223 m.start (); // return 3 m.end (); // return 7, le numéro d'index après 2223 m.group (); // renvoie 2223 Mathcer m2 = m.matcher ("2223bb"); M.lookingat (); // correspond à 2223 m.start (); // retourne 0, puisque lookat () ne peut correspondre que la chaîne précédente, lors de l'utilisation de lookat () à correspondre, la méthode start () renvoie toujours 0 m.end (); // retour 4 m.group (); // Retour 2223 Matcher M3 = M.Matcher ("2223BB"); m.matches (); // correspond à la chaîne entière m.start (); // Retour 0, je crois que tout le monde connaît la raison m.end (); // Retour 6, je crois que tout le monde connaît la raison, car Matches () doit correspondre à tous les string m.group (); // retour 2223BB Cela dit, je crois que tout le monde comprend l'utilisation des méthodes ci-dessus. Nous devons parler de la façon dont le regroupement d'expression régulière est utilisé dans Java.
Il existe une méthode surchargée pour start() , end() et group() Ils sont start(int i) , end(int i) , group(int i) spécifiquement pour les opérations de groupe. La classe MathCer a également un groupCount() pour retourner le nombre de groupes.
Exemple de code Java:
Pattern p = motifs.compile ("([az] +) (// d +)"); Matcher m = p.matcher ("aaa2223bb"); m.find (); // correspond à AAA2223 M.GroupCount (); // retour 2, car il y a 2 groupes de m.start (1); // return 0 renvoie le numéro d'index du premier groupe de sous-chaînes correspondantes dans la chaîne M.Start (2); // retourne 3 M.end (1); // Renvoie 3 Renvoie la position d'index du dernier caractère du premier groupe de sous-chaînes correspondantes dans la chaîne. M.end (2); // retourne 7 m.group (1); // Renvoie AAA, renvoie le premier groupe de sous-chaînes appariées M.Group (2); // Retour 2223, retournez le deuxième ensemble de sous-chaînes correspondantes Utilisons maintenant une opération de correspondance régulière de niveau légèrement supérieur, par exemple, il y a un morceau de texte avec de nombreux nombres, et ces chiffres sont séparés. Nous devons maintenant éliminer tous les chiffres du texte. Il est si simple d'utiliser des opérations régulières Java.
Exemple de code Java:
Pattern p = motive.compile ("// d +"); Matcher M = P.Matcher ("Mon QQ est: 456456 Mon téléphone est: 0532214 Mon e-mail est: [email protected]"); while (m.find ()) {System.out.println (m.group ()); }Sortir:
456456 0532214 123
Si vous remplacez la boucle ci-dessus while()
while (m.find ()) {System.out.println (m.group ()); System.out.print ("start:" + m.start ()); System.out.println ("end:" + M.end ()); }Puis sortie:
456456 Démarrage: 6 Fin: 12 0532214 Début: 19 Fin: 26 123 Démarrage: 36 Fin: 39
Maintenant, tout le monde doit savoir qu'après chaque opération d'appariement, les valeurs des trois méthodes start() , end() et group() seront modifiées et seront transformées dans les informations de la sous-chaîne d'appariement, et leurs méthodes de surcharge seront également transformées en informations correspondantes.
Remarque: Ce n'est que lorsque l'opération de correspondance est réussie que vous pouvez utiliser les trois méthodes start() , end() et group() , sinon java.lang.IllegalStateException sera lancée, c'est-à-dire que lorsque l'une des méthodes matches() , lookingAt() , find() return true, elle peut être utilisée.
Résumer
Ce qui précède est tout le contenu de cet article. J'espère que le contenu de cet article sera d'une aide à votre étude ou à votre travail. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.