2.2Reguläre Ausdrücke 

Ein regulärer Ausdruck (engl. regular expression) ist die Beschreibung eines Musters (engl. pattern). Reguläre Ausdrücke werden bei der Zeichenkettenverarbeitung beim Suchen und Ersetzen eingesetzt. Für folgende Szenarien bietet die Java-Bibliothek entsprechende Unterstützung an:

• Frage nach einer kompletten Übereinstimmung: Passt eine Zeichenfolge komplett auf ein Muster? Wir nennen das match. Die Rückgabe einer solchen Anfrage ist einfach wahr oder falsch.

• Finde Teil-Strings: Das Pattern beschreibt einen Teil-String, und gesucht sind alle Vorkommen dieses Musters in einem Such-String.

• Ersetze Teilfolgen: Das Pattern beschreibt Wörter, die durch andere Wörter ersetzt werden.

• Zerlegen einer Zeichenfolge: Das Muster steht für Trennzeichnen, sodass nach dem Zerlegen eine Sammlung von Zeichenfolgen entsteht.

Ein Pattern-Matcher ist die »Maschine«, die reguläre Ausdrücke verarbeitet. Zugriff auf diese Mustermaschine bietet die Klasse Matcher. Dazu kommt die Klasse Pattern, die die regulären Ausdrücke in einem vorcompilierten Format repräsentiert. Beide Klassen befinden sich im Paket java.util.regex. Um die Sache etwas zu vereinfachen, gibt es bei String zwei kleine Hilfsmethoden, die im Hintergrund auf die Klassen verweisen, um eine einfachere API anbieten zu können; diese nennen sich auch Fassaden-Methoden.

 

2.2.1Pattern.matches(…) bzw. String#matches(…) 

Die statische Methode java.util.regex.Pattern.matches(…) und die Objektmethode matches(…) der Klasse String testen, ob ein regulärer Ausdruck eine Zeichenfolge komplett beschreibt.

Wir wollen testen, ob eine Zeichenfolge in einfache Hochkommata eingeschlossen ist:

Tabelle 2.1Einfache reguläre Ausdrücke und ihr Ergebnis

Der Punkt im regulären Ausdruck steht für ein beliebiges Zeichen, und der folgende Stern ist ein Quantifizierer, der wahllos viele beliebige Zeichen erlaubt.

Regeln für reguläre Ausdrücke

Für reguläre Ausdrücke existiert eine ganze Menge an Regeln. Während die meisten Zeichen aus dem Alphabet erlaubt sind, besitzen Zeichen wie der Punkt, die Klammer, ein Sternchen und einige weitere Zeichen Sonderfunktionen. So maskiert auch ein vorangestelltes »\« das folgende Sonderzeichen aus, was bei besonderen Zeichen wie ».« oder »\« wichtig ist. Zunächst gilt es, die Anzahl an Wiederholungen zu bestimmen. Dazu dient ein Quantifizierer (auch Wiederholungsfaktor genannt). Drei wichtige gibt es. Für eine Zeichenkette X gilt:

Tabelle 2.2Quantifizierer im Umgang mit einer Zeichenkette X

Eine Sonderform ist X(?!Y) – das drückt aus, dass der reguläre Ausdruck Y dem regulären Ausdruck Xnicht folgen darf (die API-Dokumentation spricht von »zero-width negative lookahead«).

Tabelle 2.3Beispiele für reguläre Ausdrücke mit Wiederholungen

Da in regulären Ausdrücken oftmals ein Bereich von Zeichen, etwa alle Buchstaben, abgedeckt werden muss, gibt es die Möglichkeit, Zeichenklassen zu definieren.

Tabelle 2.4Definition von Zeichenklassen

Das »^« definiert negative Zeichenklassen, also Zeichen, die nicht vorkommen dürfen. Mit dem »-« lässt sich ein Bereich von Zeichen angeben.

Listing 2.1RegExDemo.java, main(), Ausschnitt

Daneben gibt es vordefinierte Zeichenklassen, die in erster Linie Schreibarbeit ersparen. Die wichtigsten sind:

Tabelle 2.5Vordefinierte Zeichenklassen

Weitere vordefinierte Zeichenklassen listet die API-Dokumentation http://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html auf.

Bei den Wortzeichen handelt es sich standardmäßig um die ASCII-Zeichen und nicht um deutsche Zeichen mit unseren Umlauten oder allgemeine Unicode-Zeichen. Eine umfassende Übersicht liefert die API-Dokumentation der Klasse java.util.regex.Pattern.

Listing 2.2RegExDemo.java, main(), Ausschnitt

 

2.2.2Die Klassen Pattern und Matcher 

Der Aufruf der Objektmethode matches(String) auf einem String-Objekt bzw. das statische Pattern.matches(String, CharSequence) ist nur eine Abkürzung für die Übersetzung eines Patterns und Anwendung von matches() auf einem Matcher-Objekt.

Tabelle 2.6Implementierungen der beiden matches()-Methoden

Während also die Objektmethode matches(String) von String zu Pattern.matches(String, CharSequence) delegiert, steht hinter der statischen Fassadenmethode in Pattern die wirkliche Nutzung der beiden zentralen Klassen Pattern für das Muster und Matcher für die Mustermaschine. Für unser erstes Beispiel Pattern.matches("'.*'", "'Hallo Welt'") hätten wir also äquivalent schreiben können:

• static Pattern compile(String regex)
  Übersetzt den regulären Ausdruck in ein Pattern-Objekt.

• static Pattern compile(String regex, int flags)
  Übersetzt den regulären Ausdruck in ein Pattern-Objekt mit Flags. Als Flags sind CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE, CANON_EQ und UNICODE_CHARACTER_CLASS erlaubt.

• int flags()
  Liefert die Flags, auf die geprüft wird.

• Matcher matcher(CharSequence input)
  Liefert ein Matcher-Objekt, das prüft.

• static boolean matches(String regex, CharSequence input)
  Liefert true, wenn der reguläre Ausdruck regex auf die Eingabe passt.

• static Stringquote(String s)
  Maskiert die Metazeichen/Escape-Sequenzen aus. So liefert Pattern.quote("*.[\\d") den String \Q*.[\d\E.

• String pattern()
  Liefert den regulären Ausdruck, den das Pattern-Objekt repräsentiert.

Zwei weitere split(…)-Methoden finden sich bei String und Pattern; Abschnitt 2.3.1, »Zerlegen von Zeichensequenzen über String oder Pattern«, kommt darauf zurück.

• boolean matches()
  Testet den gesamten bei Pattern übergebenen String auf Übereinstimmung.

• Matcher reset()
  Setzt die Zustände vom Matcher zurück.

• Matcher reset(CharSequence input)
  Setzt die Zustände zurück und weist eine neue Zeichenfolge zu. Normalerweise bekommt der Matcher den String von Pattern übergeben, doch mit dieser Methode lässt sich eine neue zu testende Zeichenfolge zuweisen.

• boolean lookingAt()
  Schaut, ob der Anfang der Eingabe mit dem regulären Ausdruck übereinstimmt.

• boolean matches(String regex)
  Äquivalent zu Pattern.matches(regex, this /*String*/).

Pattern-Flags *

Die Flags sind in speziellen Situationen ganz hilfreich, etwa wenn die Groß-/Kleinschreibung keine Rolle spielt oder sich die Suche über eine Zeile erstrecken soll. Doch Java zwingt uns nicht, die Pattern-Klasse zu nutzen, um die Flags einsetzen zu können, sondern erlaubt es, mit einer speziellen Schreibweise die Flags auch im regulären Ausdruck selbst anzugeben, was die Nutzung bei String#matches(String) ermöglicht.

Tabelle 2.7Pattern-Flags

In einem regulären Ausdruck sind die Varianten rechts sehr praktisch, da sie an unterschiedlichen Positionen ein- und ausgeschaltet werden können. Ein nach dem Fragezeichen platziertes Minus stellt die Option wieder ab, etwa "(?i)jetzt insensitive(?-i) wieder sensitive". Mehrere Flag-Ausdrücke lassen sich auch zusammensetzen, etwa zu "(?ims)".

In der Praxis häufiger im Einsatz sind Pattern.DOTALL/(?s), Pattern.CASE_INSENSITIVE/(?i) und Pattern.MULTILINE/(?m). Es folgen Beispiele, wobei wir MULTILINE bei den Wortgrenzen vorstellen.

Standardmäßig matcht der ».« kein Zeilenendezeichen, sodass ein regulärer Ausdruck einen Zeilenumbruch nicht erkennt. Das lässt sich mit dem Pattern.DOTALL-Flag bzw. (?s) ändern.

Quantifizierer und Wiederholungen *

Neben den Quantifizierern ? (einmal oder keinmal), * (keinmal oder beliebig oft) und + (einmal oder beliebig oft) gibt es drei weitere Quantifizierer, die es erlauben, die Anzahl eines Vorkommens genauer zu beschreiben:

• X{n}. X muss genau n-mal vorkommen.

• X{n,}. X kommt mindestens n-mal vor.

• X{n,m}. X kommt mindestens n-, aber maximal m-mal vor.

Ränder und Grenzen testen *

Die bisherigen Ausdrücke waren nicht ortsgebunden, sondern haben geprüft, ob es irgendwo im String eine Übereinstimmung gibt. Dateiendungen zum Beispiel sind aber – wie der Name schon sagt – am Ende zu prüfen, genauso wie ein URL-Protokoll wie »http://« am Anfang stehen muss. Um diese Anforderungen mit berücksichtigen zu können, können bestimmte Positionen mit in einem regulären Ausdruck gefordert werden. Die Pattern-API erlaubt folgende Matcher:

Tabelle 2.8Erlaubte Matcher

Wichtig ist zu verstehen, dass diese Matcher keine »Breite« haben, also nicht wirklich ein Zeichen oder eine Zeichenfolge matchen, sondern lediglich die Position beschreiben.

Die Matcher ^ und $ lösen gut das Problem mit den Dateiendungen und HTTP-Protokollen und leisten gute Dienste bei bestimmten Löschanweisungen.

Der Matcher \b ist nützlich, wenn es darum geht, ein Wort umrandet von Weißraum in einer Teilzeichenkette zu finden. In der Zeichenkette »Spaß in China innerhalb der Grenzen« wird die Suche nach »in« drei Fundstellen ergeben, aber \bin\b nur eine und \bin\B auch eine, und zwar »innerhalb«. Es matcht demnach ein \b genau die Stelle, bei der ein \w auf ein \W folgt (bzw. andersherum).

Multiline-Modus *

Normalerweise sind ^ und $nicht zeilenorientiert, das heißt, es ist ihnen egal, ob im String Zeilenumbruchzeichen wie \n oder \r vorkommen oder nicht. Mitunter soll der Test aber lokal auf einer Zeile stattfinden – hierzu muss der Multiline-Modus aktiviert werden.

Der Multiline-Modus erklärt auch den Grund, warum es gleich mehrere Grenz-Matcher gibt. Die Matches \A und \Z bzw. \z sind im Prinzip wie ^ und $, unterscheiden sich aber dann, wenn der Multiline-Modus aktiviert ist. Dann arbeiten (wie im Beispiel) ^ und $ zeilenorientiert, \A und \Z bzw. \z aber nie – die letzten drei Matcher kennen Zeilentrenner überhaupt nicht. Damit ist "Fwd:\nHi,\nalles OK!".matches("(?sm).*\\AHi,\\Z.*") auch trotz (?sm) ganz einfach false.

Es bleiben \z und \Z. Sie unterscheiden, ob bei Zeilen, die abschließende Zeilentrenner wie \n oder \r besitzen, diese Zeilentrenner mit zum Match gehören oder nicht. Das \z ist wie $ ein Matcher auf das absolute Ende inklusive aller Zeilentrenner. Das große \Z ignoriert am Ende stehende Zeilentrenner, sodass sozusagen der Match schon vorher zu Ende ist.

 

2.2.3Finden und nicht matchen 

Bisher haben wir mit regulären Ausdrücken lediglich festgestellt, ob eine Zeichenfolge vollständig auf ein Muster passt. Doch genau genommen hat Matcher drei Aufgaben:

• Abgleich: Das Pattern muss auf die gesamte Eingabe passen. Das übernimmt matches().

• Anschauen: Die Eingabe muss mit dem Muster beginnen. Das prüft lookingAt().

• Finden: Das Muster muss irgendwie in der Eingabe vorkommen.

Die Matcher-Klasse kann also feststellen, ob sich eine durch ein Muster beschriebene Teilfolge im String befindet. Dazu dient die Methode find(…). Sie hat zwei Aufgaben: Zunächst sucht sie nach einer Fundstelle und gibt bei Erfolg true zurück. Das Nächste ist, dass jedes Matcher-Objekt einen Zustand mit Fundstellen besitzt, den find() aktualisiert. Einem Matcher-Objekt entlockt die Methode group(…) den erkannten Substring, und start(…)/end(…) liefert die Positionen. Wiederholte Aufrufe von find(…) setzen die Positionen weiter:

Listing 2.3RegExAllNumbers.java, main()

Die Ausgabe des Zahlenfinders ist:

Die gefundene Gruppe und die Start-/Endposition des letztes Ergebnisses liefern group(…), start(…) und end(…). Die Methoden gibt es in drei Versionen. Für die komplette Übereinstimmung sind es group(), start(), end(), und matcher.group() entspricht dem Teil-String von matcher.start(g) bis matcher.end(g). Gruppen können mit einem Index bzw. mit einem Namen versehen werden, auf die dann group(int), group(String) zugreifen, und die Position liefern start(int)/start(String) und end(int)/end(String).

 

2.2.4Gruppen 

In regulären Ausdrücken lassen sich Teilausdrücke in runde Klammern setzen, und diese bilden dann Gruppen; im Englischen heißen sie capturing groups. Gruppen haben zwei Vorteile:

• An die Gruppe gesetzte Operationen wirken für die Gruppe. Beispiel: Der Ausdruck (\d\d)+ steht für eine gerade Anzahl von Ziffern.

• Eine Gruppe fängt einen Teil-String, und auf den lässt sich gezielt zurückgreifen.

 

2.2.5Gierige und nicht gierige Operatoren * 

Die drei Operatoren ?, * und + haben die Eigenschaft, die längste mögliche Zeichenfolge abzudecken – das nennt sich gierig (engl. greedy). Deutlich wird diese Eigenschaft bei dem Versuch, in einem HTML-String alle fett gesetzten Teile zu finden. Gesucht ist also ein Ausdruck, der im String

die Teilfolgen <b>fett</b> und <b>Cool</b> erkennt. Der erste Versuch für ein Programm könnte so aussehen:

Nun ist die Ausgabe aber <b>fett</b>. <b>Cool</b>! Das verwundert nicht, denn mit dem Wissen, dass * gierig ist, passt <b>.*</b> auf die Zeichenkette vom ersten <b> bis zum letzten </b>.

Die Lösung ist der Einsatz eines nicht gierigen Operators (auch genügsam, zurückhaltend, non-greedy oder reluctant genannt). In diesem Fall wird hinter den Qualifizierer einfach ein Fragezeichen gestellt:

Tabelle 2.9Gierige und nicht gierige Operatoren

Mit einem solchen nicht gierigen Operator lösen wir einfach das Fettproblem:

Listing 2.4RegExFindBold.java, main()

Wie gewünscht ist die Ausgabe:

 

2.2.6Mit MatchResult alle Ergebnisse einsammeln * 

Die Schnittstelle java.util.regex.MatchResult deklariert Operationen, die Zugriff auf das Ergebnis (String, Startposition, Endposition, Anzahl der Gruppen) eines Matches ermöglichen. Ein Matcher-Objekt wird dafür mit toMatchResult() nach dem MatchResult-Objekt gefragt.

Ein einfaches Beispiel verdeutlicht die Arbeitsweise: Die eigene statische Utility-Methode findMatches() soll für ein Muster und eine Zeichenkette alle Ergebnisse zurückliefern:

Listing 2.5MatchResultDemo.java, Teil 1

Abbildung 2.1Die Matcher-Klasse implementiert die MatcherResult-Schnittstelle.

Die Methode liefert ein einfaches Iterable zurück, was in unserem Beispiel ausreicht, um die Methode auf der rechten Seite des Doppelpunktes vom erweiterten for nutzen zu können. Vor dem Schleifendurchlauf übersetzt compile(…) den Muster-String in ein Pattern-Objekt, und matcher(…) gibt Zugang zum konkreten Mustererkenner, also Matcher-Objekt. Die Bedingung der Schleife ist so, dass pro Durchlauf ein Muster erkannt wird. Im Rumpf der Schleife sammelt die Ergebnisliste die MatchResult-Objekte, die die Funddaten repräsentieren. Nach Ablauf der Schleife liefert die Methode die gesammelten Objekte zurück. Das Programm greift mit Iterable, Collection und ArrayList auf Typen aus den Datenstrukturen zurück.

Ein paar Programmzeilen zeigen schnell die Möglichkeiten. Ein einfaches Muster soll für ISBN-10-Nummern stehen – ohne Leerzeichen oder Bindestriche:

Listing 2.6MatchResultDemo.java, Teil 2

Das Ergebnis auf der Konsole ist:

Die Informationen in einem MatchResult entsprechen also einem Zustand eines Matchers während des Parsens, genauer gesagt nach dem Erkennen einer Zeichenfolge. Daher implementiert auch die Klasse Matcher die Schnittstelle MatchResult.

 

2.2.7Suchen und Ersetzen mit Mustern 

Von der Pattern/Matcher-Klasse haben wir bisher zwei Eigenschaften kennengelernt: zum einen, wie sie prüft, ob eine komplette Zeichenkette auf ein Muster passt, und zum anderen die Suchmöglichkeit, dass find(…) uns sagt, an welchen Stellen ein Muster in einer Zeichenkette vorkommt. Für den zweiten Fall gibt es noch eine Erweiterung, dass nämlich die Pattern-Klasse die Fundstellen nicht nur ermittelt, sondern sie auch durch etwas anderes ersetzen kann.

Um mit dem Mechanismus »Suchen und Ersetzen« zu arbeiten, wird zunächst ein StringBuffer aufgebaut, denn in dem echten String kann Pattern die Fundstellen nicht ersetzen. (Leider ist ein StringBuffer nötig, die API akzeptiert keinen StringBuilder.) Erkennt der Matcher ein Muster, ersetzt appendReplacement(…) es durch eine Alternative, die in den StringBuffer kommt. So wächst der StringBuffer von Schritt zu Schritt. Nach der letzten Fundstelle setzt appendTail(…) das noch verbleibende Teilstück an den StringBuffer.

Toll an appendReplacement(…) ist, dass die Ersetzung nicht einfach nur ein einfacher String ist, sondern dass er mit $ Zugriff auf die Suchgruppe hat. Damit lassen sich sehr elegante Lösungen bauen. Nehmen wir an, wir müssen in einer Zeichenkette alle URLs in HTML-Hyperlinks konvertieren. Dann rahmen wir einfach jede Fundstelle in die nötigen HTML-Tags ein. In Quellcode sieht das so aus:

Listing 2.7RegExSearchAndReplace.java, main()

Der StringBuffer enthält dann zum Schluss "Hi, schau mal bei <a href="http://stackoverflow.com/">http://stackoverflow.com/</a> oder <a href="http://www.tutego.de/">http://www.tutego.de/</a> vorbei.". (Der gewählte reguläre Ausdruck für URLs ist kurz, aber nicht vollständig. Für das Beispiel spielt das aber keine Rolle.)

 

2.2.8Hangman Version 2 

Im ersten Band der Insel wurde ein Hangman-Spiel vorgestellt, das Ersetzungen ohne reguläre Ausdrücke vornimmt. Mit regulären Ausdrücken lässt sich eine ganz spezielle Aufgabe unseres Hangman-Spiels noch verbessern. Wir hatten die Aufgabe, dass ungeratene Zeichen durch einen Unterstrich ersetzt werden. Diese Ersetzung kann sehr gut replaceAll(…) übernehmen:

Listing 2.8Hangman2.java