Java Regex - Kurzanleitung

Java bietet das Paket java.util.regex für den Mustervergleich mit regulären Ausdrücken. Die regulären Java-Ausdrücke sind der Perl-Programmiersprache sehr ähnlich und sehr einfach zu erlernen.

Ein regulärer Ausdruck ist eine spezielle Folge von Zeichen, mit deren Hilfe Sie andere Zeichenfolgen oder Sätze von Zeichenfolgen mithilfe einer speziellen Syntax in einem Muster abgleichen oder finden können. Sie können zum Suchen, Bearbeiten oder Bearbeiten von Text und Daten verwendet werden.

Das Paket java.util.regex besteht hauptsächlich aus den folgenden drei Klassen:

• Pattern Class- Ein Pattern-Objekt ist eine kompilierte Darstellung eines regulären Ausdrucks. Die Pattern-Klasse bietet keine öffentlichen Konstruktoren. Um ein Muster zu erstellen, müssen Sie zuerst eine seiner öffentlichen statischen Elemente aufrufencompile()Methoden, die dann ein Pattern-Objekt zurückgeben. Diese Methoden akzeptieren einen regulären Ausdruck als erstes Argument.

• Matcher Class- Ein Matcher-Objekt ist die Engine, die das Muster interpretiert und Übereinstimmungsoperationen für eine Eingabezeichenfolge ausführt. Wie die Pattern-Klasse definiert Matcher keine öffentlichen Konstruktoren. Sie erhalten ein Matcher-Objekt, indem Sie das aufrufenmatcher() Methode für ein Pattern-Objekt.

• PatternSyntaxException - Ein PatternSyntaxException-Objekt ist eine nicht aktivierte Ausnahme, die auf einen Syntaxfehler in einem Muster mit regulären Ausdrücken hinweist.

Das Erfassen von Gruppen ist eine Möglichkeit, mehrere Zeichen 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 mit den Buchstaben "d", "o" und "g".

Erfassungsgruppen werden nummeriert, indem ihre öffnenden Klammern von links nach rechts gezählt werden. In dem Ausdruck ((A) (B (C))) gibt es zum Beispiel vier solche Gruppen -

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

Rufen Sie die groupCount-Methode für ein Matcher-Objekt auf, um herauszufinden, wie viele Gruppen im Ausdruck vorhanden sind. Die groupCount-Methode gibt eine zurückint Zeigt die Anzahl der Erfassungsgruppen 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 Summe enthalten.

Beispiel

Das folgende Beispiel zeigt, wie Sie eine Ziffernfolge aus der angegebenen alphanumerischen Zeichenfolge finden.

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 führt zu folgendem Ergebnis:

Ausgabe

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Einführung

Das java.util.regex.MatchResultSchnittstelle repräsentiert das Ergebnis einer Übereinstimmungsoperation. Diese Schnittstelle enthält Abfragemethoden, mit denen die Ergebnisse einer Übereinstimmung mit einem regulären Ausdruck ermittelt werden. Die Übereinstimmungsgrenzen, Gruppen und Gruppengrenzen können durch ein MatchResult angezeigt, aber nicht geändert werden.

Schnittstellendeklaration

Es folgt die Erklärung für java.util.regex.MatchResult Schnittstelle -

public interface MatchResult

Schnittstellenmethoden

Sr.Nr.	Methode & Beschreibung
1	int end () Gibt den Versatz nach dem letzten übereinstimmenden Zeichen zurück.
2	int end (int group) Gibt den Versatz nach dem letzten Zeichen der Teilsequenz zurück, die von der angegebenen Gruppe während dieser Übereinstimmung erfasst wurde.
3	String group () Gibt die Eingabe-Teilsequenz zurück, die mit der vorherigen Übereinstimmung übereinstimmt.
4	String-Gruppe (int-Gruppe) Gibt die Eingabesubsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.
5	int groupCount () Gibt die Anzahl der Erfassungsgruppen im Muster dieses Übereinstimmungsergebnisses zurück.
6	int start () Gibt den Startindex der Übereinstimmung zurück.
7	int start (int group) Gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während dieses Spiels erfasst wurde.

Einführung

Das java.util.regex.Pattern Klasse repräsentiert eine kompilierte Darstellung eines regulären Ausdrucks.

Klassenerklärung

Es folgt die Erklärung für java.util.regex.Pattern Klasse -

public final class Pattern
   extends Object
      implements Serializable

Feld

Es folgen die Felder für java.util.regex.Duration Klasse -

• static int CANON_EQ - Aktiviert die kanonische Äquivalenz.

• static int CASE_INSENSITIVE - Aktiviert die Übereinstimmung ohne Berücksichtigung der Groß- und Kleinschreibung.

• static int COMMENTS - Ermöglicht Leerzeichen und Kommentare im Muster.

• static int DOTALL - Aktiviert den Dotall-Modus.

• static int LITERAL - Aktiviert das wörtliche Parsen des Musters.

• static int MULTILINE - Aktiviert den mehrzeiligen Modus.

• static int UNICODE_CASE - Aktiviert die Unicode-fähige Fallfaltung.

• static int UNICODE_CHARACTER_CLASS - Aktiviert die Unicode-Version von vordefinierten Zeichenklassen und POSIX-Zeichenklassen.

• static int UNIX_LINES - Aktiviert den Unix-Leitungsmodus.

Klassenmethoden

Sr.Nr.	Methode & Beschreibung
1	statische Musterkompilierung (String regex) Kompiliert den angegebenen regulären Ausdruck zu einem Muster.
2	statische Musterkompilierung (String regex, int flags) Kompiliert den angegebenen regulären Ausdruck zu einem Muster mit den angegebenen Flags.
3	int flags () Gibt die Übereinstimmungsflags dieses Musters zurück.
4	Matcher Matcher (CharSequence-Eingabe) Erstellt einen Matcher, der die angegebene Eingabe mit diesem Muster vergleicht.
5	statische boolesche Übereinstimmungen (String-Regex, CharSequence-Eingabe) Kompiliert den angegebenen regulären Ausdruck und versucht, die angegebene Eingabe mit dieser abzugleichen.
6	String pattern () Gibt den regulären Ausdruck zurück, aus dem dieses Muster kompiliert wurde.
7	statisches String-Zitat (String s) Gibt einen Literalmuster-String für den angegebenen String zurück.
8	String [] split (CharSequence-Eingabe) Teilt die angegebene Eingabesequenz um Übereinstimmungen dieses Musters.
9	String [] split (CharSequence-Eingabe, int limit) Teilt die angegebene Eingabesequenz um Übereinstimmungen dieses Musters.
10	String toString () Gibt die Zeichenfolgendarstellung dieses Musters zurück.

Methoden geerbt

Diese Klasse erbt Methoden von den folgenden Klassen:

• Java.lang.Object

Einführung

Das java.util.regex.Matcher Die Klasse fungiert als Engine, die Übereinstimmungsoperationen für eine Zeichenfolge durch Interpretation eines Musters ausführt.

Klassenerklärung

Es folgt die Erklärung für java.util.regex.Matcher Klasse -

public final class Matcher
   extends Object
      implements MatchResult

Klassenmethoden

Sr.Nr.	Methode & Beschreibung
1	Matcher appendReplacement (StringBuffer sb, String-Ersetzung) Implementiert einen nicht-terminalen Schritt zum Anhängen und Ersetzen.
2	StringBuffer appendTail (StringBuffer sb) Implementiert einen Schritt zum Anhängen und Ersetzen des Terminals.
3	int end () Gibt den Versatz nach dem letzten übereinstimmenden Zeichen zurück.
4	int end (int group) Gibt den Versatz nach dem letzten Zeichen der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.
5	boolean find () Versucht, die nächste Teilsequenz der Eingabesequenz zu finden, die dem Muster entspricht.
6	boolescher Fund (int start) Setzt diesen Matcher zurück und versucht dann, die nächste Teilsequenz der Eingabesequenz zu finden, die dem Muster entspricht, beginnend mit dem angegebenen Index.
7	String group () Gibt die Eingabesubsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.
8	String-Gruppe (String-Name) Gibt die Eingabe-Teilsequenz zurück, die von der angegebenen Gruppe mit benannter Erfassung während der vorherigen Übereinstimmungsoperation erfasst wurde.
9	int groupCount () Gibt die Anzahl der Erfassungsgruppen im Muster dieses Matchers zurück.
10	boolean hasAnchoringBounds () Fragt die Verankerung von Regionsgrenzen für diesen Matcher ab.
11	boolean hasTransparentBounds () Fragt die Transparenz der Regionsgrenzen für diesen Matcher ab.
12	boolean hitEnd () Gibt true zurück, wenn das Ende der Eingabe von der Suchmaschine in der letzten von diesem Matcher ausgeführten Übereinstimmungsoperation getroffen wurde.
13	Boolescher LookAt () Versuche, die Eingabesequenz, beginnend am Anfang der Region, mit dem Muster abzugleichen.
14	Boolesche Übereinstimmungen () Versuche, die gesamte Region mit dem Muster abzugleichen.
15	Muster Muster () Gibt das Muster zurück, das von diesem Matcher interpretiert wird.
16	statischer String quoteReplacement (String s) Gibt eine Literal-Ersatzzeichenfolge für die angegebene Zeichenfolge zurück.
17	Matcher-Region (int start, int end) Legt die Grenzen der Region dieses Matchers fest.
18	int regionEnd () Gibt den Endindex (exklusiv) der Region dieses Matchers an.
19	int regionStart () Gibt den Startindex der Region dieses Matchers an.
20	String replaceAll (Stringersatz) Ersetzt jede Teilsequenz der Eingabesequenz, die dem Muster entspricht, durch die angegebene Ersetzungszeichenfolge.
21	String replaceFirst (Stringersatz) Ersetzt die erste Teilsequenz der Eingabesequenz, die dem Muster entspricht, durch die angegebene Ersetzungszeichenfolge.
22	boolean requireEnd () Gibt true zurück, wenn mehr Eingaben eine positive Übereinstimmung in eine negative ändern könnten.
23	Matcher zurücksetzen () Setzt diesen Matcher zurück.
24	Matcher-Reset (CharSequence-Eingabe) Setzt diesen Matcher mit einer neuen Eingabesequenz zurück.
25	int start () Gibt den Startindex der vorherigen Übereinstimmung zurück.
26	int start (int group) Gibt den Startindex der Teilsequenz zurück, die von der angegebenen Gruppe während der vorherigen Übereinstimmungsoperation erfasst wurde.
27	MatchResult toMatchResult () Gibt den Übereinstimmungsstatus dieses Matchers als MatchResult zurück.
28	String toString () Gibt die Zeichenfolgendarstellung dieses Matchers zurück.
29	Matcher useAnchoringBounds (boolean b) Legt die Verankerung von Regionsgrenzen für diesen Matcher fest.
30	Matcher usePattern (Pattern newPattern) Ändert das Muster, mit dem dieser Matcher Übereinstimmungen findet.
31	Matcher useTransparentBounds (boolean b) Legt die Transparenz der Regionsgrenzen für diesen Matcher fest.

Methoden geerbt

Diese Klasse erbt Methoden von den folgenden Klassen:

• Java.lang.Object

Einführung

Das java.util.regex.PatternSyntaxException Klasse stellt eine ungeprüfte Ausnahme dar, die ausgelöst wird, um einen Syntaxfehler in einem Muster mit regulären Ausdrücken anzuzeigen.

Klassenerklärung

Es folgt die Erklärung für java.util.regex.PatternSyntaxException Klasse -

public class PatternSyntaxException
   extends IllegalArgumentException

Konstruktoren

Sr.Nr.	Methode & Beschreibung
1	PatternSyntaxException(String desc, String regex, int index) Erstellt eine neue Instanz dieser Klasse.

Klassenmethoden

Sr.Nr.	Methode & Beschreibung
1	String getDescription() Ruft die Beschreibung des Fehlers ab.
2	int getIndex() Ruft den Fehlerindex ab.
3	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.
4	String getPattern() Ruft das fehlerhafte Muster für reguläre Ausdrücke ab.

Methoden geerbt

Diese Klasse erbt Methoden von den folgenden Klassen:

• Java.lang.Throwable
• Java.lang.Object

Beispiel

Das folgende Beispiel zeigt die Verwendung der Klassenmethoden java.util.regex.Pattern.PatternSyntaxException.

package com.tutorialspoint;

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

public class PatternSyntaxExceptionDemo {
   private static String REGEX = "[";
   private static String INPUT = "The dog says meow " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);
         
         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT); 
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

Lassen Sie uns das obige Programm kompilieren und ausführen. Dies führt zu folgendem Ergebnis:

PatternSyntaxException: 
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

Im Folgenden finden Sie verschiedene Beispiele für übereinstimmende Zeichen, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	x Das Zeichen x
2	\\ Der Backslash-Charakter
3	\ 0n Das Zeichen mit dem Oktalwert 0n (0 ≤ n ≤ 7)
4	\ 0nn Das Zeichen mit dem Oktalwert 0nn (0 ≤ n ≤ 7)
5	\ 0mnn Das Zeichen mit dem Oktalwert 0mnn (0 ≤ m ≤ 3, 0 ≤ n ≤ 7)
6	\ xhh Das Zeichen mit dem Hexadezimalwert 0xhh
7	\ uhhhh Das Zeichen mit dem Hexadezimalwert 0xhhhh
8	\ t Das Tabulatorzeichen ('\ u0009')
9	\ n Das Zeilenumbruchzeichen ('\ u000A')
10	\ r Das Wagenrücklaufzeichen ('\ u000D')
11	\ f Das Formular-Feed-Zeichen ('\ u000C')

Im Folgenden finden Sie verschiedene Beispiele für übereinstimmende Zeichenklassen mit regulären Ausdrücken in Java.

Sr.Nr.	Konstruieren & Matches
1	[ABC] a, b oder c (einfache Klasse).
2	[^ abc] Beliebiges Zeichen außer a, b oder c (Negation).
3	[a-zA-Z] a bis z oder A bis einschließlich Z (Bereich).
4	[ad [mp]] a bis d oder m bis p: [a-dm-p] (Vereinigung).
5	[az && [def]] d, e oder f (Schnittpunkt).
6	[az && [^ bc]] a bis z, außer b und c: [ad-z] (Subtraktion)
7	[az && [^ mp]] a bis z und nicht m bis p: [a-lq-z] (Subtraktion).

Im Folgenden finden Sie verschiedene Beispiele für den Abgleich vordefinierter Zeichenklassen mit regulären Ausdrücken in Java.

Sr.Nr.	Konstruieren & Matches
1	. Beliebiges Zeichen (kann mit Zeilenabschlusszeichen übereinstimmen oder nicht).
2	\ d Eine Ziffer: [0-9].
3	\ D. Eine nichtstellige Zahl: [^ 0-9].
4	\ s Ein Leerzeichen: [\ t \ n \ x0B \ f \ r]
5	\ S. Ein Nicht-Leerzeichen: [^ \ s].
6	\ w Ein Wortzeichen: [a-zA-Z_0-9].
7	\ W. Ein Nicht-Wort-Zeichen: [^ \ w]

Im Folgenden finden Sie verschiedene Beispiele für übereinstimmende POSIX-Zeichenklassen mit regulären Ausdrücken in Java.

Sr.Nr.	Konstruieren & Matches
1	\ p {Lower} Ein alphabetisches Kleinbuchstabenzeichen: [az].
2	\ p {Upper} Ein alphabetisches Zeichen in Großbuchstaben: [AZ].
3	\ p {ASCII} Alle ASCII: [\ x00- \ x7F].
4	\ p {Alpha} Ein alphabetisches Zeichen: [\ p {Lower} \ p {Upper}].
5	\ p {Digit} Eine Dezimalstelle: [0-9].
6	\ p {Alnum} Ein alphanumerisches Zeichen: [\ p {Alpha} \ p {Digit}].
7	\ p {Punct} Interpunktion: Eine von! "# $% & '() * +, -. /:; <=>? @ [\] ^ _> {|} <.
8	\ p {Graph} Ein sichtbares Zeichen: [\ p {Alnum} \ p {Punct}].
9	\ p {Drucken} Ein druckbares Zeichen: [\ p {Graph} \ x20].
10	\ p {Leer} Ein Leerzeichen oder eine Registerkarte: [\ t].
11	\ p {XDigit} Eine hexadezimale Ziffer: [0-9a-fA-F].
12	\ p {Leerzeichen} Ein Leerzeichen: [\ t \ n \ x0B \ f \ r].

Im Folgenden finden Sie verschiedene Beispiele für die Übereinstimmung von JAVA-Zeichenklassen mit regulären Ausdrücken in Java.

Sr.Nr.	Konstruieren & Matches
1	\ p {javaLowerCase} Entspricht java.lang.Character.isLowerCase ().
2	\ p {javaUpperCase} Entspricht java.lang.Character.isUpperCase ().
3	\ p {javaWhitespace} Entspricht java.lang.Character.isWhitespace ().
4	\ p {javaMirrored} Entspricht java.lang.Character.isMirrored ().

Im Folgenden finden Sie verschiedene Beispiele für den Abgleich von Unicode-Zeichenklassen mit regulären Ausdrücken in Java.

Sr.Nr.	Konstruieren & Matches
1	\ p {IsLatin} Ein lateinisches Schriftzeichen.
2	\ p {InGreek} Ein Charakter im griechischen Block.
3	\ p {Lu} Ein Großbuchstabe.
4	\ p {IsAlphabetic} Ein alphabetisches Zeichen (binäre Eigenschaft).
5	\ p {Sc} Ein Währungssymbol.
6	\ P {InGreek} Jedes Zeichen außer einem im griechischen Block.
7	[\ p {L} && [^ \ p {Lu}]] Jeder Buchstabe außer einem Großbuchstaben.

Im Folgenden finden Sie verschiedene Beispiele für Boundary Matcher, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	^ Der Anfang einer Zeile.
2	$ Das Ende einer Zeile.
3	\ b Eine Wortgrenze.
4	\ B. Eine Nicht-Wort-Grenze.
5	\EIN Der Beginn der Eingabe.
6	\G Das Ende des vorherigen Spiels.
7	\ Z. Das Ende der Eingabe, jedoch für den endgültigen Abschluss, falls vorhanden.
8	\ z Das Ende der Eingabe.

Ein gieriger Quantifizierer zeigt der Suchmaschine an, die gesamte Zeichenfolge zu durchsuchen und zu prüfen, ob sie mit dem angegebenen regulären Ausdruck übereinstimmt. Im Folgenden finden Sie verschiedene Beispiele für gierige Quantifizierer, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	X? X, einmal oder gar nicht.
2	X * X, null oder mehrmals
3	X + X, einmal oder mehrmals.
4	X {n} X, genau n mal.
5	X {n,} X, mindestens n-mal.
6	X {n, m} X, mindestens n, aber nicht mehr als m Mal

Ein widerstrebender Quantifizierer gibt an, dass die Suchmaschine mit dem kürzestmöglichen Teil der Zeichenfolge beginnen soll. Sobald eine Übereinstimmung gefunden wurde, fährt der Motor fort. Andernfalls wird dem zu überprüfenden Abschnitt der Zeichenfolge ein Zeichen hinzugefügt und danach gesucht usw. Dieser Vorgang folgt, bis eine Übereinstimmung gefunden wird oder die gesamte Zeichenfolge aufgebraucht ist. Im Folgenden finden Sie verschiedene Beispiele für Reluctant Quantifiers, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	X ?? X, einmal oder gar nicht.
2	X *? X, null oder mehrmals
3	X +? X, einmal oder mehrmals.
4	X {n}? X, genau n mal.
5	X {n,}? X, mindestens n-mal.
6	X {n, m}? X, mindestens n, aber nicht mehr als m Mal

Ein Possessivquantifizierer ähnelt einem gierigen Quantifizierer. Es zeigt an, dass die Engine durch Überprüfen der gesamten Zeichenfolge gestartet werden soll. Es unterscheidet sich in dem Sinne, wenn es nicht funktioniert, wenn die Übereinstimmung fehlgeschlagen ist und kein Rückblick besteht. Im Folgenden finden Sie verschiedene Beispiele für Possessive Quantifiers, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	X? + X, einmal oder gar nicht.
2	X * + X, null oder mehrmals
3	X ++ X, einmal oder mehrmals.
4	X {n} + X, genau n mal.
5	X {n,} + X, mindestens n-mal.
6	X {n, m} + X, mindestens n, aber nicht mehr als m Mal

Im Folgenden finden Sie verschiedene Beispiele für logische Operatoren, die reguläre Ausdrücke in Java verwenden.

Sr.Nr.	Konstruieren & Matches
1	XY X gefolgt von Y.
2	X | Y. Entweder X oder Y.

Drucken