Reguläre Ausdrücke

Suchen in Strings

Gesucht ist ein Programm zum Extrahieren von Telefonnummern aus E-Mails.

=> Wie geht das?

Leider gibt es unzählig viele Varianten, wie man eine Telefonnummer (samt Vorwahl und ggf. Ländervorwahl) aufschreiben kann:

030 - 123 456 789, 030-123456789, 030/123456789,
+49(30)123456-789, +49 (30) 123 456 - 789, ...

Definition Regulärer Ausdruck

Ein regulärer Ausdruck ist eine Zeichenkette, die zur Beschreibung von Zeichenketten dient.

Anwendungen

• Finden von Bestandteilen in Zeichenketten
• Aufteilen von Strings in Tokens
• Validierung von textuellen Eingaben => "Eine Postleitzahl besteht aus 5 Ziffern"
• Compilerbau: Erkennen von Schlüsselwörtern und Strukturen und Syntaxfehlern

Einfachste reguläre Ausdrücke

Beispiel

• abc => "abc"
• A.B => "AAB" oder "A2B" oder ...
• a\\bc => "a\bc"

Anmerkung

In Java-Strings leitet der Backslash eine zu interpretierende Befehlssequenz ein. Deshalb muss der Backslash i.d.R. geschützt ("escaped") werden. => Statt "\n" müssen Sie im Java-Code "\\n" schreiben!

Zeichenklassen

Beispiel

• [abc] => "a" oder "b" oder "c"
• [a-c] => "a" oder "b" oder "c"
• [a-c][a-c] => "aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb" oder "cc"
• A[a-c] => "Aa", "Ab" oder "Ac"

Vordefinierte Ausdrücke

Beispiel

• \d\d\d\d\d => "12345"
• \w\wA => "aaA", "a0A", "a_A", ...

Nutzung in Java

• java.lang.String:

  public String[] split(String regex)
  public boolean matches(String regex)

• java.util.regex.Pattern:

  public static Pattern compile(String regex)
  public Matcher matcher(CharSequence input)

  • Schritt 1: Ein Pattern compilieren (erzeugen) mit Pattern#compile => liefert ein Pattern-Objekt für den regulären Ausdruck zurück
  • Schritt 2: Dem Pattern-Objekt den zu untersuchenden Zeichenstrom übergeben mit Pattern#matcher => liefert ein Matcher-Objekt zurück, darin gebunden: Pattern (regulärer Ausdruck) und die zu untersuchende Zeichenkette

• java.util.regex.Matcher:

  public boolean find()
  public boolean matches()
  public int groupCount()
  public String group(int group)

  • Schritt 3: Mit dem Matcher-Objekt kann man die Ergebnisse der Anwendung des regulären Ausdrucks auf eine Zeichenkette auswerten

    Bedeutung der unterschiedlichen Methoden siehe folgende Folien

    Matcher#group: Liefert die Sub-Sequenz des Suchstrings zurück, die erfolgreich gematcht wurde (siehe unten "Fangende Gruppierungen")

Hinweis:

In Java-Strings leitet der Backslash eine zu interpretierende Befehlssequenz ein. Deshalb muss der Backslash i.d.R. extra geschützt ("escaped") werden.

=> Statt "\n" (regulärer Ausdruck) müssen Sie im Java-String "\\n" schreiben!

=> Statt "a\\bc" (regulärer Ausdruck, passt auf die Zeichenkette "a\bc") müssen Sie im Java-String "a\\\\bc" schreiben!

Unterschied zw. Finden und Matchen

• Matcher#find:

  Regulärer Ausdruck muss im Suchstring enthalten sein. => Suche nach erstem Vorkommen

• Matcher#matches:

  Regulärer Ausdruck muss auf kompletten Suchstring passen.

Beispiel

• Regulärer Ausdruck: abc, Suchstring: "blah blah abc blub"
  • Matcher#find: erfolgreich
  • Matcher#matches: kein Match - Suchstring entspricht nicht dem Muster

Quantifizierung

Beispiel

• \d{5} => "12345"
• -?\d+\.\d* => ???

Interessante Effekte

Pattern p = Pattern.compile("A.*A");
Matcher m = p.matcher("A 12 A 45 A");

if (m.matches())
    String result = m.group(); // ???

Matcher#group liefert die Inputsequenz, auf die der Matcher angesprochen hat. Mit Matcher#start und Matcher#end kann man sich die Indizes des ersten und letzten Zeichens des Matches im Eingabezeichenstrom geben lassen. D.h. für einen Matcher m und eine Eingabezeichenkette s ist m.group() und s.substring(m.start(), m.end()) äquivalent.

Da bei Matcher#matches das Pattern immer auf den gesamten Suchstring passen muss, verwundert das Ergebnis für Matcher#group nicht. Bei Matcher#find wird im Beispiel allerdings ebenfalls der gesamte Suchstring "gefunden" ... Dies liegt am "greedy" Verhalten der Quantifizierer.

Nicht gierige Quantifizierung mit "?"

Beispiel

• Suchstring "A 12 A 45 A":

  • A.*A findet/passt auf "A 12 A 45 A"

    normale greedy Variante

  • A.*?A

    • findet "A 12 A"
    • passt auf "A 12 A 45 A" (!)

    non-greedy Variante der Quantifizierung; Matcher#matches muss trotzdem auf den gesamten Suchstring passen!

(Fangende) Gruppierungen

Studi{2} passt nicht auf "StudiStudi" (!)

Quantifizierung bezieht sich auf das direkt davor stehende Zeichen. Ggf. Gruppierungen durch Klammern verwenden!

Beispiel

• (A)(B(C))
  • Gruppe 0: ABC
  • Gruppe 1: A
  • Gruppe 2: BC
  • Gruppe 3: C

Die Gruppen heißen auch "fangende" Gruppen (engl.: "capturing groups").

Damit erreicht man eine Segmentierung des gesamten regulären Ausdrucks, der in seiner Wirkung aber nicht durch die Gruppierungen geändert wird. Durch die Gruppierungen von Teilen des regulären Ausdrucks erhält man die Möglichkeit, auf die entsprechenden Teil-Matches (der Unterausdrücke der einzelnen Gruppen) zuzugreifen:

• Matcher#groupCount: Anzahl der "fangenden" Gruppen im regulären Ausdruck

• Matcher#group(i): Liefert die Subsequenz der Eingabezeichenkette zurück, auf die die jeweilige Gruppe gepasst hat. Dabei wird von links nach rechts durchgezählt, beginnend bei 1(!).

  Konvention: Gruppe 0 ist das gesamte Pattern, d.h. m.group(0) == m.group(); ...

Hinweis: Damit der Zugriff auf die Gruppen klappt, muss auch erst ein Match gemacht werden, d.h. das Erzeugen des Matcher-Objekts reicht noch nicht, sondern es muss auch noch ein matcher.find() oder matcher.matches() ausgeführt werden. Danach kann man bei Vorliegen eines Matches auf die Gruppen zugreifen.

(Studi){2} => "StudiStudi"

Gruppen und Backreferences

Matche zwei Ziffern, gefolgt von den selben zwei Ziffern

• Verweis auf bereits gematchte Gruppen: \num

  num Nummer der Gruppe (1 ... 9)

  => Verweist nicht auf regulären Ausdruck, sondern auf jeweiligen Match!

  Anmerkung: Laut Literatur/Doku nur 1 ... 9, in Praxis geht auch mehr per Backreference ...

• Benennung der Gruppe: (?<name>X)

  X ist regulärer Ausdruck für Gruppe, spitze Klammern wichtig

  => Backreference: \k<name>

Beispiel Gruppen und Backreferences

Regulärer Ausdruck: Namen einer Person matchen, wenn Vor- und Nachname identisch sind.

Lösung: ([A-Z][a-zA-Z]*)\s\1

Umlaute und reguläre Ausdrücke

• Keine vordefinierte Abkürzung für Umlaute (wie etwa \d)

• Umlaute nicht in [a-z] enthalten, aber in [a-ü]

  "helloüA".matches(".*?[ü]A");
  "azäöüß".matches("[a-ä]");
  "azäöüß".matches("[a-ö]");
  "azäöüß".matches("[a-ü]");
  "azäöüß".matches("[a-ß]");

• Strings sind Unicode-Zeichenketten

  => Nutzung der passenden Unicode Escape Sequence \uFFFF

  System.out.println("\u0041 :: A");
  System.out.println("helloüA".matches(".*?A"));
  System.out.println("helloüA".matches(".*?\u0041"));
  System.out.println("helloü\u0041".matches(".*?A"));

• RegExp vordefinieren und mit Variablen zusammenbauen ala Perl nicht möglich => Umweg String-Repräsentation

Wrap-Up

• RegExp: Zeichenketten, die andere Zeichenketten beschreiben
• java.util.regex.Pattern und java.util.regex.Matcher
• Unterschied zwischen Matcher#find und Matcher#matches!
• Quantifizierung ist möglich, aber greedy (Default)