Vorwort
In diesem Artikel wird die Musternklasse und die Matcher -Klasse in regulären Java -Ausdrücken vorgestellt. Zunächst müssen wir klar verstehen, dass der reguläre als Zeichenfolge festgelegte reguläre Ausdruck zunächst als Instanz der Musterklasse kompiliert werden muss. Wie man diese beiden Klassen besser versteht, müssen Programmierer wissen.
Schauen wir uns diese beiden Kategorien an:
1. Das Konzept der Erfassung von Gruppen
Die Erfassungsgruppe kann nummeriert werden, indem ihre offenen Klammern von links nach rechts berechnet werden. Dies beginnt beispielsweise im Ausdruck ((a) (b (c)). Es gibt vier solcher Gruppen:
1 ((a) (b (c)) 2 (a) 3 (b (c)) 4 (c)
Gruppennullen repräsentieren immer den gesamten Ausdruck. Gruppen beginnend mit (?) Sind reine Nicht-Kauf-Gruppen, die keinen Text erfassen und nicht mit Combo-Zählungen zählen.
Der mit einer Gruppe verbundene Erfassungseingang ist immer die Subsequenz, die zuletzt der Gruppe entspricht. Wenn die Gruppe aufgrund der Quantisierung erneut berechnet wird, wird ihr zuvor erfasster Wert beim zweiten Berechnungsfehler (falls vorhanden) beibehalten. Wenn Sie beispielsweise die Zeichenfolge "ABA" mit dem Ausdruck (a (b)?)+ Übereinstimmen, wird die zweite Gruppe auf "B" festgelegt. Zu Beginn jedes Spiels werden alle erfassten Eingänge verworfen.
2. Detaillierte Erläuterung von Muster- und Matcher -Klassen
Die regulären Ausdrücke von Java werden in der Musternklasse und der Matcher -Klasse unter dem Paket java.util.regex implementiert (es wird empfohlen, das Java -API -Dokument beim Lesen dieses Artikels zu öffnen. Wenn Sie die Methode eingeführt werden, überprüfen Sie die Methodenbeschreibung in der Java -API und der Effekt ist besser).
Die Musterklasse wird verwendet, um einen regelmäßigen Ausdruck zu erstellen, oder es kann gesagt werden, dass ein Matching -Muster erstellt wird. Seine Konstruktionsmethode ist privat und kann nicht direkt erstellt werden, kann jedoch durch die einfache Fabrikmethode von Pattern.complie(String regex)
Beispiel für Java -Code:
Muster p = muster.comPile ("// w+"); P.Pattern (); // return/w+ pattern() gibt die Zeichenfolgeform eines regulären Ausdrucks zurück, der tatsächlich der Regex -Parameter von Pattern.complile(String regex) ist.
1.Pattern.Split (charsequence -Eingabe)
Das Muster hat eine split(CharSequence input) , mit der Zeichenfolgen getrennt und eine String [] zurückgegeben werden. Ich denke, String.split(String regex) wird über Pattern.split(CharSequence input) implementiert.
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); String [] str = p.Split ("Mein QQ ist: 456456 Mein Telefon ist: 0532214 Meine E -Mail ist: [email protected]");Ergebnis: st [0] = "Mein QQ ist:" st [1] = "Mein Telefon ist:" st [2] = "Meine E -Mail ist: [email protected]"
2. Muster.Matcher (String Regex, Charsequence Input) ist eine statische Methode, mit der schnell die Zeichenfolgen übereinstimmt. Diese Methode eignet sich für nur einmal übereinstimmen und alle Saiten abgleichen.
Beispiel für Java -Code:
Muster.Matches ("// d+", "2223"); // Return true Muster.Matches ("// d+", "2223aa"); // Return Falsch, alle Saiten müssen so angepasst werden, dass es zu True zurückkehrt wird.3.PUCHERN.MATCHER (CHAR SEWENCE INPUT)
Nachdem es so viel gesagt hat, ist es endlich die Ablauf der Matchernklasse zum Debüt. Pattern.matcher(CharSequence input) gibt ein Matcher -Objekt zurück.
Die Konstruktor -Methode der Matcher -Klasse ist ebenfalls privat und kann nach Belieben nicht erstellt werden. Es kann nur Instanzen dieser Klasse über Pattern.matcher(CharSequence input) erhalten.
Die Musterklasse kann nur einige einfache Übereinstimmungsvorgänge ausführen. Um stärkere und bequemere reguläre Matching -Operationen zu erzielen, ist es erforderlich, mit Muster und Matcher zusammenzuarbeiten. Die Matcher -Klasse bietet Gruppierungsunterstützung für reguläre Ausdrücke und mehrere Matching -Unterstützung für reguläre Ausdrücke.
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.pattern (); // return p, das zurückgibt, welches Musterobjekt vom Matching -Objekt erstellt wurde.4.Matcher.Matches ()/matcher.lookingat ()/matcher.find ()
Die Matcher -Klasse bietet drei Übereinstimmungsmethoden. Alle drei Methoden geben den Booleschen Typ zurück. Return True, wenn das Match erreicht ist. Wenn es keine Übereinstimmung gibt, gibt es falsch zurück.
matches() übereinstimmt zur gesamten Zeichenfolge und kehrt nur dann true zurück, wenn die gesamte Zeichenfolge übereinstimmt
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.matches (); // return false, da BB nicht mit/d+übereinstimmt werden kann, was zur Übereinstimmung der gesamten Zeichenfolge erfolgreich ist. Matcher M2 = p.matcher ("2223"); M2.Matches (); // Return true, weil/d+ die gesamte Zeichenfolge übereinstimmt Schauen wir zurück auf Pattern.matcher(String regex,CharSequence input) , der dem folgenden Code entspricht
Pattern.compile(regex).matcher(input).matches()
lookingAt() entspricht der vorherigen Zeichenfolge und kehrt nur dann true zurück, wenn sich die passende Zeichenfolge vorne befindet.
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.lookingat (); // return true, weil/d+ mit dem vorherigen 22 Matcher M2 = p.matcher ("AA2223") übereinstimmt; m2.Lookingat (); // false zurückgeben, weil/d+ nicht mit dem vorherigen AA übereinstimmen kann find() stimmt mit der Zeichenfolge überein, und die passende Zeichenfolge kann überall sein.
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("22BB23"); m.find (); // return true Matcher m2 = p.matcher ("AA2223"); m2.find (); // return true Matcher m3 = p.matcher ("aa2223bb"); m3.find (); // RECHTUNG WAHR TRAUT M4 = P.Matcher ("Aabb"); m4.find (); // return false5.Mathcer.Start ()/matcher.end ()/matcher.group ()
Nach Verwendung von matches() , lookingAt() und find() , um Matching -Operationen durchzuführen, können Sie die oben genannten drei Methoden verwenden, um detailliertere Informationen zu erhalten.
start() gibt die Indexposition des passenden Substring in der Zeichenfolge zurück.
end() gibt die Indexposition des letzten Zeichens des übereinstimmenden Substring in der Zeichenfolge zurück.
group() gibt das passende Substring zurück
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("AAA2223BB"); M.Find (); // Match 2223 M.Start (); // return 3 m.end (); // return 7, die Indexnummer nach 2223 m.group (); // return 2223 mathcer m2 = m.matcher ("2223bb"); m.lookingat (); // Match 2223 M.Start (); // return 0, da Lookat () nur mit der vorherigen Zeichenfolge übereinstimmen kann, wenn man Lookat () zu übereinstimmen, gibt die Start () -Methode immer 0 m.end () zurück. // return 4 m.group (); // Rückgabe 2223 Matcher M3 = M.Matcher ("2223BB"); M.Matches (); // übereinstimmen den gesamten String M.Start (); // Rückkehr 0, ich glaube, jeder kennt den Grund, warum M.end (); // Rückkehr 6, ich glaube, jeder kennt den Grund, weil Matches () alle Zeichenfolgen m.group () übereinstimmen; // Rückgabe 2223bb Ich glaube, jeder versteht die Verwendung der oben genannten Methoden. Wir sollten darüber sprechen, wie die regelmäßige Ausdrucksgruppierung in Java verwendet wird.
Es gibt eine überlastete Methode für start() , end() und group() Sie sind start(int i) , end(int i) , group(int i) speziell für Gruppenoperationen. Die Mathcer -Klasse hat auch einen groupCount() um die Anzahl der Gruppen zurückzugeben.
Beispiel für Java -Code:
Muster p = muster.comPile ("([Az]+) (// d+)"); Matcher M = P.Matcher ("AAA2223BB"); m.find (); // Match aaa2223 m.groupcount (); // Rückkehr 2, weil es 2 Gruppen von M.Start gibt (1); // Rückgabe 0 gibt die Indexnummer der ersten Gruppe von übereinstimmenden Substrings in der String M.Start (2) zurück; // Rücksende 3 M.end (1); // Gibt 3 die Indexposition des letzten Zeichens der ersten Gruppe von übereinstimmenden Substrings in der Zeichenfolge zurück. M.end (2); // Rücksende 7 M.group (1); // gibt AAA zurück und gibt die erste Gruppe von übereinstimmenden Substrings M.Group (2) zurück; // Rückgabe 2223, geben Sie die zweite Gruppe passender Substrings zurück Verwenden wir nun einen etwas höheren regulären Übereinstimmungsvorgang. Zum Beispiel gibt es einen Text mit vielen Zahlen, und diese Zahlen sind getrennt. Jetzt müssen wir alle Zahlen im Text herausnehmen. Es ist so einfach, Java reguläre Operationen zu verwenden.
Beispiel für Java -Code:
Muster p = muster.comPile ("// d+"); Matcher M = P.Matcher ("Mein QQ ist: 456456 Mein Telefon ist: 0532214 Meine E -Mail ist: [email protected]"); while (m.find ()) {System.out.println (m.group ()); }Ausgabe:
456456 0532214 123
Wenn Sie die oben genannte while() Schleife durch
while (m.find ()) {System.out.println (m.group ()); System.out.print ("Start:"+M.Start ()); System.out.println ("Ende:"+M.end ()); }Dann Ausgabe:
456456 Start: 6 Ende: 12 0532214 Start: 19 Ende: 26 123 Start: 36 Ende: 39
Jetzt sollte jeder wissen, dass nach jedem Übereinstimmungsvorgang die Werte der drei Methoden start() , end() und group() werden geändert und in die Informationen des passenden Substrings geändert und ihre Überlastungsmethoden auch in die entsprechenden Informationen geändert.
Hinweis: Nur wenn der Matching -Operation erfolgreich ist, können Sie die drei Methoden start() , end() und group() , ansonsten java.lang.IllegalStateException ausgeworfen, dh wenn eine der Methoden matches() , lookingAt() , find() return true, kann es nur verwendet werden.
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels für Ihr Studium oder Ihre Arbeit hilfreich sein wird. Wenn Sie Fragen haben, können Sie eine Nachricht zur Kommunikation überlassen. Vielen Dank für Ihre Unterstützung bei Wulin.com.