Java - Reguläre Ausdrücke
Java stellt das Paket java.util.regex für den Musterabgleich mit regulären Ausdrücken bereit. Reguläre Java-Ausdrücke sind der Programmiersprache Perl sehr ähnlich und sehr leicht zu erlernen.
Ein regulärer Ausdruck ist eine spezielle Folge von Zeichen, die Ihnen hilft, andere Zeichenfolgen oder Zeichenfolgengruppen mithilfe einer speziellen Syntax, die in einem Muster enthalten ist, abzugleichen oder zu finden. Sie können verwendet werden, um Text und Daten zu suchen, zu bearbeiten oder zu manipulieren.
Das Paket java.util.regex besteht hauptsächlich aus den folgenden drei Klassen −
-
Musterklasse − Ein Pattern-Objekt ist eine kompilierte Darstellung eines regulären Ausdrucks. Die Pattern-Klasse stellt keine öffentlichen Konstruktoren bereit. Um ein Muster zu erstellen, müssen Sie zuerst eines seiner öffentlichen statischen compile() aufrufen Methoden, die dann ein Pattern-Objekt zurückgeben. Diese Methoden akzeptieren einen regulären Ausdruck als erstes Argument.
-
Matcher-Klasse − Ein Matcher-Objekt ist die Engine, die das Muster interpretiert und Übereinstimmungsoperationen mit einer Eingabezeichenfolge durchführt. Wie die Pattern-Klasse definiert Matcher keine öffentlichen Konstruktoren. Sie erhalten ein Matcher-Objekt, indem Sie matcher() aufrufen -Methode für ein Musterobjekt.
-
PatternSyntaxException − Ein PatternSyntaxException-Objekt ist eine ungeprüfte Ausnahme, die einen Syntaxfehler in einem regulären Ausdrucksmuster anzeigt.
Erfassungsgruppen
Einfangende Gruppen sind eine Möglichkeit, mehrere Charaktere als eine Einheit zu behandeln. Sie werden erstellt, indem die zu gruppierenden Zeichen in Klammern gesetzt werden. Beispielsweise erstellt der reguläre Ausdruck (Hund) eine einzelne Gruppe, die die Buchstaben „d“, „o“ und „g“ enthält.
Fanggruppen werden nummeriert, indem ihre öffnenden Klammern von links nach rechts gezählt werden. Im Ausdruck ((A)(B(C))) gibt es beispielsweise vier solcher Gruppen −
- ((A)(B(C)))
- (A)
- (B(C))
- (C)
Um herauszufinden, wie viele Gruppen im Ausdruck vorhanden sind, rufen Sie die groupCount-Methode für ein Matcher-Objekt auf. Die groupCount-Methode gibt ein int zurück Zeigt die Anzahl der einfangenden Gruppen an, die im Matcher-Muster vorhanden sind.
Es gibt auch eine spezielle Gruppe, Gruppe 0, die immer den gesamten Ausdruck darstellt. Diese Gruppe ist nicht in der von groupCount gemeldeten Gesamtzahl enthalten.
Beispiel
Das folgende Beispiel zeigt, wie man eine Ziffernfolge aus der gegebenen alphanumerischen Folge findet −
Live-Demo
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
public static void main( String args[] ) {
// String to be scanned to find the pattern.
String line = "This order was placed for QT3000! OK?";
String pattern = "(.*)(\\d+)(.*)";
// Create a Pattern object
Pattern r = Pattern.compile(pattern);
// Now create matcher object.
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
}else {
System.out.println("NO MATCH");
}
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT300 Found value: 0
Syntax für reguläre Ausdrücke
Hier ist die Tabelle, die die gesamte in Java verfügbare Metazeichensyntax für reguläre Ausdrücke auflistet −
| Unterausdruck | Übereinstimmungen |
|---|---|
| ^ | Entspricht dem Anfang der Zeile. |
| $ | Entspricht dem Zeilenende. |
| . | Entspricht jedem einzelnen Zeichen außer Newline. Mit m Option erlaubt es auch, den Zeilenumbruch zu finden. |
| [...] | Entspricht jedem einzelnen Zeichen in Klammern. |
| [^...] | Entspricht jedem einzelnen Zeichen, das nicht in Klammern steht. |
| \A | Beginn der gesamten Zeichenfolge. |
| \z | Ende der gesamten Zeichenfolge. |
| \Z | Ende der gesamten Zeichenkette mit Ausnahme des zulässigen Zeilenabschlusszeichens. |
| re* | Übereinstimmung mit 0 oder mehr Vorkommen des vorhergehenden Ausdrucks. |
| re+ | Entspricht 1 oder mehr der vorherigen Sache. |
| re? | Übereinstimmung mit 0 oder 1 Vorkommen des vorhergehenden Ausdrucks. |
| re{ n} | Entspricht genau n Vorkommen des vorhergehenden Ausdrucks. |
| re{n,} | Übereinstimmung mit n oder mehr Vorkommen des vorhergehenden Ausdrucks. |
| re{ n, m} | Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks. |
| a| b | Entspricht entweder a oder b. |
| (re) | Gruppiert reguläre Ausdrücke und merkt sich den übereinstimmenden Text. |
| (?:re) | Gruppiert reguläre Ausdrücke, ohne sich an den übereinstimmenden Text zu erinnern. |
| (?> re) | Entspricht dem unabhängigen Muster ohne Backtracking. |
| \w | Entspricht den Wortzeichen. |
| \W | Entspricht den Nichtwortzeichen. |
| \s | Entspricht dem Leerzeichen. Entspricht [\t\n\r\f]. |
| \S | Entspricht dem Nicht-Leerzeichen. |
| \d | Entspricht den Ziffern. Entspricht [0-9]. |
| \D | Entspricht den Nichtziffern. |
| \A | Entspricht dem Anfang der Zeichenfolge. |
| \Z | Entspricht dem Ende der Zeichenfolge. Wenn ein Zeilenumbruch vorhanden ist, passt er direkt vor Zeilenumbruch. |
| \z | Entspricht dem Ende der Zeichenfolge. |
| \G | Entspricht dem Punkt, an dem das letzte Match endete. |
| \n | Rückverweis auf Erfassungsgruppennummer "n". |
| \b | Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht dem Backspace (0x08) innerhalb der Klammern. |
| \B | Entspricht den Nichtwortgrenzen. |
| \n, \t usw. | Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw. |
| \Q | Escape (Anführungszeichen) für alle Zeichen bis \E. |
| \E | Beendet das mit \Q begonnene Zitieren. |
Methoden der Matcher-Klasse
Hier ist eine Liste nützlicher Instanzmethoden −
Indexmethoden
Indexmethoden liefern nützliche Indexwerte, die genau zeigen, wo die Übereinstimmung in der Eingabezeichenfolge gefunden wurde −
| Sr.No. | Methode &Beschreibung |
|---|---|
| 1 | public int start() Gibt den Startindex des vorherigen Spiels zurück. |
| 2 | public int start(int group) Gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde. |
| 3 | public int end() Gibt den Offset nach dem letzten übereinstimmenden Zeichen zurück. |
| 4 | public int end(int group) Gibt den Versatz nach dem letzten Zeichen der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Vergleichsoperation erfasst wurde. |
Studienmethoden
Studienmethoden überprüfen die Eingabezeichenfolge und geben einen booleschen Wert zurück, der angibt, ob das Muster gefunden wurde oder nicht −
| Sr.No. | Methode &Beschreibung |
|---|---|
| 1 | öffentliches boolesches lookingAt() Versucht, die Eingabesequenz, beginnend am Anfang der Region, mit dem Muster abzugleichen. |
| 2 | öffentlicher boolescher Suchbegriff() Versucht, die nächste Teilsequenz der Eingabesequenz zu finden, die mit dem Muster übereinstimmt. |
| 3 | öffentlicher boolescher Wert find(int start) Setzt diesen Matcher zurück und versucht dann, die nächste Teilsequenz der Eingabesequenz zu finden, die mit dem Muster übereinstimmt, beginnend am angegebenen Index. |
| 4 | öffentliche boolesche Übereinstimmungen() Versucht, die gesamte Region mit dem Muster abzugleichen. |
Ersetzungsmethoden
Ersetzungsmethoden sind nützliche Methoden zum Ersetzen von Text in einer Eingabezeichenfolge −
| Sr.No. | Methode &Beschreibung |
|---|---|
| 1 | öffentlicher Matcher appendReplacement(StringBuffer sb, String-Ersetzung) Implementiert einen nicht-terminalen Append-and-Replace-Schritt. |
| 2 | öffentlicher StringBuffer appendTail(StringBuffer sb) Implementiert einen abschließenden Schritt zum Anhängen und Ersetzen. |
| 3 | öffentlicher String replaceAll(String-Ersetzung) Ersetzt jede Teilsequenz der Eingabesequenz, die mit dem Muster übereinstimmt, durch die angegebene Ersetzungszeichenfolge. |
| 4 | öffentlicher String replaceFirst(String-Ersetzung) Ersetzt die erste Teilsequenz der Eingabesequenz, die mit dem Muster übereinstimmt, durch die angegebene Ersetzungszeichenfolge. |
| 5 | öffentlicher statischer String quoteReplacement(String s) Gibt einen wörtlichen Ersatz-String für den angegebenen String zurück. Diese Methode erzeugt einen String, der als wörtlicher Ersatz für s dient in der appendReplacement-Methode der Matcher-Klasse. |
Die Start- und Endmethoden
Im folgenden Beispiel wird gezählt, wie oft das Wort "Katze" in der Eingabezeichenfolge erscheint −
Beispiel
Live-Demo
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); // get a matcher object
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());
}
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
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
Sie können sehen, dass dieses Beispiel Wortgrenzen verwendet, um sicherzustellen, dass die Buchstaben „c“ „a“ „t“ nicht nur eine Teilzeichenfolge in einem längeren Wort sind. Es gibt auch einige nützliche Informationen darüber, wo in der Eingabezeichenfolge die Übereinstimmung aufgetreten ist.
Die start-Methode gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde, und die end-Methode gibt den Index des letzten gefundenen Zeichens plus eins zurück.
Die Matches und lookingAt-Methoden
Die Methoden matchs und lookingAt versuchen beide, eine Eingabesequenz mit einem Muster abzugleichen. Der Unterschied besteht jedoch darin, dass für „Matches“ die gesamte Eingabesequenz abgeglichen werden muss, während für „LookingAt“ dies nicht der Fall ist.
Beide Methoden beginnen immer am Anfang des Eingabestrings. Hier ist das Beispiel, das die Funktionalität erklärt −
Beispiel
Live-Demo
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());
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
Current REGEX is: foo Current INPUT is: fooooooooooooooooo lookingAt(): true matches(): false
Die Methoden replaceFirst und replaceAll
Die Methoden replaceFirst und replaceAll ersetzen den Text, der mit einem bestimmten regulären Ausdruck übereinstimmt. Wie der Name schon sagt, ersetzt replaceFirst das erste Vorkommen und replaceAll alle Vorkommen.
Hier ist das Beispiel, das die Funktionalität erklärt −
Beispiel
Live-Demo
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);
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
The cat says meow. All cats say meow.
Die Methoden appendReplacement und appendTail
Die Matcher-Klasse bietet auch appendReplacement- und appendTail-Methoden für die Textersetzung.
Hier ist das Beispiel, das die Funktionalität erklärt −
Beispiel
Live-Demo
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);
// get a matcher object
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()) {
m.appendReplacement(sb, REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
-foo-foo-foo-
PatternSyntaxException-Klassenmethoden
Eine PatternSyntaxException ist eine ungeprüfte Ausnahme, die einen Syntaxfehler in einem regulären Ausdrucksmuster anzeigt. Die PatternSyntaxException-Klasse stellt die folgenden Methoden bereit, um Ihnen zu helfen festzustellen, was schief gelaufen ist −
| Sr.No. | Methode &Beschreibung |
|---|---|
| 1 | öffentlicher String getDescription() Ruft die Beschreibung des Fehlers ab. |
| 2 | public int getIndex() Ruft den Fehlerindex ab. |
| 3 | öffentlicher String getPattern() Ruft das fehlerhafte reguläre Ausdrucksmuster ab. |
| 4 | öffentlicher String getMessage() Gibt eine mehrzeilige Zeichenfolge zurück, die die Beschreibung des Syntaxfehlers und seines Index, das fehlerhafte Muster für reguläre Ausdrücke und eine visuelle Anzeige des Fehlerindex innerhalb des Musters enthält. |
Java