Reguläre Java-Ausdrücke

Reguläre Ausdrücke definieren Muster von Zeichenfolgen.

Reguläre Ausdrücke können zum Suchen, Bearbeiten oder Bearbeiten von Text verwendet werden.

Reguläre Ausdrücke sind nicht auf eine Sprache beschränkt, es gibt jedoch in jeder Sprache subtile Unterschiede.

Reguläre Ausdrücke in Java sind denen von Perl am ähnlichsten.

Das Paket java.util.regex enthält hauptsächlich die folgenden drei Klassen:

• Musterklasse:

  Das Musterobjekt ist eine kompilierte Darstellung eines regulären Ausdrucks. Die Musterklasse hat keinen öffentlichen Konstruktor. Um ein Pattern-Objekt zu erstellen, müssen Sie zunächst seine öffentliche statische Kompilierungsmethode aufrufen, die ein Pattern-Objekt zurückgibt. Diese Methode akzeptiert einen regulären Ausdruck als ersten Parameter.

• Matcher-Klasse:

  Das Matcher-Objekt ist eine Engine, die Eingabezeichenfolgen interpretiert und abgleicht. Wie die Pattern-Klasse verfügt auch Matcher über keinen öffentlichen Konstruktor. Sie müssen die Matcher-Methode des Pattern-Objekts aufrufen, um ein Matcher-Objekt zu erhalten.

• PatternSyntaxException:

  PatternSyntaxException ist eine nicht obligatorische Ausnahmeklasse, die einen Syntaxfehler in einem regulären Ausdrucksmuster darstellt.

Gruppe erfassen

Das Erfassen von Gruppen ist eine Möglichkeit, mehrere Zeichen als eine Einheit zu behandeln, die durch Gruppieren von Zeichen in Klammern entsteht.

Beispielsweise erstellt der reguläre Ausdruck (Hund) eine einzelne Gruppe mit „d“, „o“ und „g“.

Einfangende Gruppen werden nummeriert, indem ihre öffnenden Klammern von links nach rechts gezählt werden. Im Ausdruck ((A)(B(C))) gibt es beispielsweise vier solcher Gruppen:

• ((ABC)))

• (A)

• (B(C))

• (C)

Sie können überprüfen, wie viele Gruppen ein Ausdruck hat, indem Sie die Methode „groupCount“ des Matcher-Objekts aufrufen. Die Methode „groupCount“ gibt einen int-Wert zurück, der angibt, dass das Matcher-Objekt derzeit über mehrere Erfassungsgruppen verfügt.

Es gibt auch eine spezielle Gruppe (Gruppe 0), die immer den gesamten Ausdruck darstellt. Die Gruppe ist nicht im Rückgabewert von groupCount enthalten.

Beispiel

Das folgende Beispiel zeigt, wie man eine Ziffernfolge aus einer bestimmten Zeichenfolge findet:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

öffentliche Klasse RegexMatches
{
public static void main( String args[] ){

// Durchsuche die Zeichenfolge gemäß dem angegebenen Muster String line = „Diese Bestellung wurde für QT3000 aufgegeben! OK?“;
String-Muster = "(.*)(\d+)(.*)";

//Pattern-Objekt erstellen Pattern r = Pattern.compile(pattern);

// Jetzt Matcher-Objekt erstellen Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Gefundener Wert: " + m.group(0) );
System.out.println("Gefundener Wert: " + m.group(1) );
System.out.println("Gefundener Wert: " + m.group(2) );
} anders {
System.out.println("NO MATCH");
}
}
}

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

 Gefundener Wert: Diese Bestellung wurde für QT3000 aufgegeben!
Gefundener Wert: Diese Bestellung wurde für QT300 aufgegeben
Gefundener Wert: 0

Syntax für reguläre Ausdrücke

Methoden der Matcher-Klasse

Indexmethode

Die Indexmethode stellt nützliche Indexwerte bereit, die genau angeben, wo in der Eingabezeichenfolge die Übereinstimmung gefunden wird:

Forschungsmethoden

Die Forschungsmethode untersucht die Eingabezeichenfolge und gibt einen booleschen Wert zurück, der angibt, ob das Muster gefunden wurde:

Ersatzmethode

Die Ersetzungsmethode ist eine Methode zum Ersetzen von Text in der Eingabezeichenfolge:

Start- und Endmethoden

Hier ist ein Beispiel für die Zählung der Häufigkeit des Worts „cat“ in einer Eingabezeichenfolge:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

öffentliche Klasse RegexMatches
{
private static final String REGEX = "\bcat\b";
privater statischer finaler String INPUT =
„Katze, Katze, Katze, Katze, Katze“;

public static void main( String args[] ){
Muster p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // Holen Sie sich das Matcher-Objekt 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());
}
}
}

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

 Spiel Nummer 1
start(): 0
end(): 3
Match Nummer 2
start(): 4
end(): 7
Match Nummer 3
start(): 8
end(): 11
Match Nummer 4
start(): 19
end(): 22

Sie können sehen, dass in diesem Beispiel Wortgrenzen verwendet werden, um sicherzustellen, dass die Buchstaben „c“, „a“ und „t“ nicht nur eine Teilzeichenfolge eines längeren Wortes sind. Es liefert auch einige nützliche Informationen darüber, wo in der Eingabezeichenfolge die Übereinstimmung aufgetreten ist.

Die Startmethode gibt den Anfangsindex der Teilsequenz zurück, die von der angegebenen Gruppe während des vorherigen Übereinstimmungsvorgangs erfasst wurde, und die Endmethode fügt eins zum Index des letzten übereinstimmenden Zeichens hinzu.

Übereinstimmungen und lookingAt-Methoden

Die Methoden „matches“ und „lookingAt“ werden beide verwendet, um zu versuchen, ein Eingabesequenzmuster abzugleichen. Der Unterschied zwischen ihnen besteht darin, dass für Übereinstimmungen die gesamte Sequenz übereinstimmen muss, während dies bei lookingAt nicht der Fall ist.

Diese beiden Methoden werden häufig am Anfang der Eingabezeichenfolge verwendet.

Zur Erläuterung dieser Funktion verwenden wir folgendes Beispiel:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

öffentliche Klasse RegexMatches
{
privater statischer finaler String REGEX = "foo";
private static final String INPUT = "fooooooooooooooooo";
privates statisches Mustermuster;
privater statischer Matcher-Matcher;

public static void main( String args[] ){
Muster = Muster.compile(REGEX);
matcher = pattern.matcher(INPUT);

System.out.println("Aktueller REGEX ist: "+REGEX);
System.out.println("Aktueller INPUT ist: "+INPUT);

System.out.println("lookingAt(): "+matcher.lookingAt());
System.out.println("matches(): "+matcher.matches());
}
}

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

 Aktueller REGEX ist: foo
Aktueller INPUT ist: fooooooooooooooooo
lookingAt(): wahr
match(): false

Methoden „replaceFirst“ und „replaceAll“.

Die Methoden „replaceFirst“ und „replaceAll“ werden verwendet, um Text zu ersetzen, der einem regulären Ausdruck entspricht. Der Unterschied besteht darin, dass „replaceFirst“ die erste Übereinstimmung ersetzt und „replaceAll“ alle Übereinstimmungen ersetzt.

Das folgende Beispiel erläutert diese Funktionalität:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

öffentliche Klasse RegexMatches
{
privater statischer String REGEX = „Hund“;
private static String INPUT = „Der Hund sagt Miau.“ +
„Alle Hunde sagen Miau.“;
privater statischer String REPLACE = "cat";

public static void main(String[] args) {
Muster p = Pattern.compile(REGEX);
//Erhalte ein Matcher-Objekt
Matcher m = p.matcher(INPUT);
INPUT = m.replaceAll(REPLACE);
System.out.println(INPUT);
}
}

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

 Die Katze sagt Miau. Alle Katzen sagen Miau.

appendReplacement- und appendTail-Methoden

Die Matcher-Klasse stellt außerdem die Methoden appendReplacement und appendTail zum Ersetzen von Text bereit:

Sehen Sie sich das folgende Beispiel an, um diese Funktionalität zu erläutern:

 import java.util.regex.Matcher;
import java.util.regex.Pattern;

öffentliche Klasse RegexMatches
{
privater statischer String REGEX = "a*b";
privater statischer String INPUT = "aabfooaabfooabfoob";
privater statischer String REPLACE = „-“;
public static void main(String[] args) {
Muster p = Pattern.compile(REGEX);
// Holen Sie sich das Matcher-Objekt Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}

Die Kompilierungs- und Ausführungsergebnisse des obigen Beispiels lauten wie folgt:

 -foo-foo-foo-

Methoden der PatternSyntaxException-Klasse

PatternSyntaxException ist eine nicht erzwungene Ausnahmeklasse, die einen Syntaxfehler in einem regulären Ausdrucksmuster anzeigt.

Die Klasse „PatternSyntaxException“ stellt die folgenden Methoden bereit, mit denen wir erkennen können, welche Fehler aufgetreten sind.