Zum Inhalt springen

Reguläre Ausdrücke

Ist 08:15 eine gültige Uhrzeit? Steht in dieser Zeile ein Datum? Wo in einem Text stehen Euro-Beträge? Für solche Fragen reichen contains und indexOf nicht mehr. Dafür gibt es reguläre Ausdrücke: kleine Muster, die beschreiben, wie ein Text aussehen soll.

  • einfache Muster lesen und schreiben
  • mit matches prüfen, ob ein ganzer Text zu einem Muster passt
  • mit Pattern und Matcher Stellen in einem Text finden und Teile herausholen
  • mit replaceAll und split arbeiten

Demo-Code: 29-regex

⤓ demo-regex.zip herunterladen

Der fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.

Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 29-regex wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.

Enthält: pom.xml, Pruefen.java, Finden.java, anwendung.log

Ein Muster ist ein Text, in dem manche Zeichen eine besondere Bedeutung haben:

Muster passt auf Beispiel
abc genau diese Zeichen abc
. ein beliebiges Zeichen a.c passt auf abc, a-c, a c
\d eine Ziffer \d\d passt auf 42
\w ein Buchstabe (ohne Umlaute), eine Ziffer oder _
\s ein Leerraum: Leerzeichen, Tabulator, Zeilenende
[abc] eines der Zeichen in der Klammer [aeiou] – ein Vokal
[a-z] eines aus dem Bereich [A-ZÄÖÜ] – ein Großbuchstabe
[^…] eines, das nicht in der Klammer steht [^0-9] – keine Ziffer
x? x null- oder einmal Kunden? passt auf Kunde und Kunden
x* x beliebig oft, auch gar nicht
x+ x mindestens einmal \d+ – eine Zahl
x{n}, x{n,m} genau n-mal, n- bis m-mal \d{5} – eine Postleitzahl
(…) eine Gruppe – für Wiederholung oder zum Herausholen (ab)+ passt auf abab
a|b a oder b (INFO|WARN|ERROR)

Soll ein besonderes Zeichen wie ., ? oder ( ganz normal gemeint sein, kommt ein Backslash davor: \. ist ein Punkt.

Pruefen.java
package de.drv.texte;
/** matches: Passt der ganze Text zum Muster? */
public class Pruefen {
public static void main(String[] args) {
pruefe("Postleitzahl", "\\d{5}", "10115", "1011", "1O115");
pruefe("Personalnummer", "\\d{4,6}", "4711", "123456", "47-11");
pruefe("Uhrzeit", "([01]\\d|2[0-3]):[0-5]\\d", "08:15", "23:59", "24:00", "8:15");
pruefe("Name", "[A-ZÄÖÜ][a-zäöüß]+( [A-ZÄÖÜ][a-zäöüß]+)*", "Anna Muster", "anna", "Jürgen Weiß");
}
static void pruefe(String was, String muster, String... beispiele) {
System.out.println(was + " " + muster);
for (String beispiel : beispiele) {
System.out.printf(" %-14s %s%n", beispiel, beispiel.matches(muster) ? "passt" : "passt nicht");
}
}
}
Terminal-Fenster
Postleitzahl \d{5}
10115 passt
1011 passt nicht
1O115 passt nicht
Personalnummer \d{4,6}
4711 passt
123456 passt
47-11 passt nicht
Uhrzeit ([01]\d|2[0-3]):[0-5]\d
08:15 passt
23:59 passt
24:00 passt nicht
8:15 passt nicht
Name [A-ZÄÖÜ][a-zäöüß]+( [A-ZÄÖÜ][a-zäöüß]+)*
Anna Muster passt
anna passt nicht
Jürgen Weiß passt
  • text.matches(muster) prüft, ob der ganze Text zum Muster passt – nicht nur ein Teil davon.
  • 1O115 passt nicht: Dort steht ein großes O, keine Null. Genau solche Fehler fängt ein Muster ab.
  • Die Uhrzeit zeigt, wie man Muster baut: Stunden sind entweder 0 oder 1 gefolgt von einer beliebigen Ziffer – oder 2 gefolgt von 0 bis 3. Dann ein Doppelpunkt, dann 0 bis 5 und eine Ziffer.
  • Beim Namen steht die Gruppe ( [A-ZÄÖÜ][a-zäöüß]+)* für „beliebig viele weitere Wörter, jeweils mit Leerzeichen davor“.

Ein Muster prüft nur die Form. Ob es den 31. Februar gibt, weiß es nicht – das prüft LocalDate.parse.

Wer nicht den ganzen Text prüfen, sondern Stellen darin finden will, nimmt zwei Klassen aus java.util.regex:

Finden.java
package de.drv.texte;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** Pattern und Matcher: Stellen in einem Text finden – und Teile davon herausholen. */
public class Finden {
// Ein Datum wie 2026-10-19 – mit drei Gruppen für Jahr, Monat, Tag
private static final Pattern DATUM = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
// Ein Betrag wie 12,50 € oder 650 €
private static final Pattern BETRAG = Pattern.compile("(\\d+)(,\\d{2})? ?€");
public static void main(String[] args) {
String text = "Die Schulung läuft vom 2026-10-19 bis zum 2026-10-23. "
+ "Die Teilnahme kostet 650 €, das Mittagessen 12,50 € am Tag.";
Matcher datum = DATUM.matcher(text);
while (datum.find()) {
System.out.println("Datum " + datum.group() + " an Stelle " + datum.start()
+ ": Tag " + datum.group(3) + ", Monat " + datum.group(2) + ", Jahr " + datum.group(1));
}
Matcher betrag = BETRAG.matcher(text);
while (betrag.find()) {
System.out.println("Betrag " + betrag.group() + " – Euro: " + betrag.group(1));
}
// Ersetzen mit Gruppen: $1, $2, $3 stehen für das, was die Gruppen gefunden haben
System.out.println(DATUM.matcher(text).replaceAll("$3.$2.$1"));
// split kennt Muster schon lange: trenne an allem, was kein Buchstabe ist
String[] woerter = "Hallo, Welt – wie geht's?".split("[^A-Za-zäöüÄÖÜß]+");
System.out.println(String.join(" | ", woerter));
}
}
Terminal-Fenster
Datum 2026-10-19 an Stelle 23: Tag 19, Monat 10, Jahr 2026
Datum 2026-10-23 an Stelle 42: Tag 23, Monat 10, Jahr 2026
Betrag 650 € – Euro: 650
Betrag 12,50 € – Euro: 12
Die Schulung läuft vom 19.10.2026 bis zum 23.10.2026. Die Teilnahme kostet 650 €, das Mittagessen 12,50 € am Tag.
Hallo | Welt | wie | geht | s
  • Pattern.compile(muster) übersetzt ein Muster einmal. Als Konstante ist es danach beliebig oft verwendbar – schneller als matches, das jedes Mal neu übersetzt.
  • muster.matcher(text) liefert einen Matcher für einen bestimmten Text. Jedes find() sucht die nächste passende Stelle und sagt, ob es eine gab – daher die while-Schleife, wie bei readLine oder next.
  • group() ist der ganze gefundene Text, group(1), group(2) … sind die Teile in den runden Klammern, von links gezählt. start() ist die Stelle im Text.
  • replaceAll ersetzt jede Fundstelle. Im Ersatztext stehen $1, $2 … für die Gruppen – so wird aus 2026-10-19 ein 19.10.2026.
  • split nimmt ebenfalls ein Muster. Das [^a-zäöüß]+ aus der Textstatistik heißt: Trenne an jeder Folge von Zeichen, die keine Buchstaben sind. Beim Apostroph in geht's fällt deshalb das s als eigenes Wort ab.

matcher.matches() gibt es auch: Es prüft wie String.matches, ob der ganze Text passt – und danach stehen die Gruppen bereit. So zerlegt man eine Zeile mit bekanntem Aufbau in ihre Teile.

Im Demo-Projekt liegt die Datei daten\anwendung.log – das Protokoll einer Zeiterfassung. Jede Zeile hat denselben Aufbau, bis auf eine:

daten/anwendung.log (Anfang)
2026-10-21 07:58:12 INFO [Start] Zeiterfassung gestartet, Version 1.4
2026-10-21 08:01:47 INFO [Anmeldung] anna.muster@example.org angemeldet
2026-10-21 08:02:03 INFO [Erfassung] Beginn 08:00 für 4711 gespeichert
2026-10-21 08:15:30 WARN [Datenbank] Verbindung langsam: 1840 ms
  1. Eingaben prüfen: Schreibe eine Klasse Eingaben mit drei statischen Methoden, die jeweils true oder false liefern: istPersonalnummer (vier bis sechs Ziffern), istUhrzeit (wie 08:15, immer zweistellig) und istDatum (wie 2026-10-21, Monat 01 bis 12, Tag 01 bis 31). null ist nie gültig. Lege dann diese Tests an und lass sie laufen:

    EingabenTest.java
    EingabenTest.java
    package de.drv.texte;
    import static org.junit.jupiter.api.Assertions.assertFalse;
    import static org.junit.jupiter.api.Assertions.assertTrue;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class EingabenTest {
    @Test
    @DisplayName("Personalnummern: vier bis sechs Ziffern")
    void personalnummer() {
    assertTrue(Eingaben.istPersonalnummer("4711"));
    assertTrue(Eingaben.istPersonalnummer("123456"));
    assertFalse(Eingaben.istPersonalnummer("471"));
    assertFalse(Eingaben.istPersonalnummer("1234567"));
    assertFalse(Eingaben.istPersonalnummer("47a1"));
    assertFalse(Eingaben.istPersonalnummer(""));
    assertFalse(Eingaben.istPersonalnummer(null));
    }
    @Test
    @DisplayName("Uhrzeiten von 00:00 bis 23:59, immer zweistellig")
    void uhrzeit() {
    assertTrue(Eingaben.istUhrzeit("00:00"));
    assertTrue(Eingaben.istUhrzeit("08:15"));
    assertTrue(Eingaben.istUhrzeit("23:59"));
    assertFalse(Eingaben.istUhrzeit("24:00"));
    assertFalse(Eingaben.istUhrzeit("12:60"));
    assertFalse(Eingaben.istUhrzeit("8:15"));
    assertFalse(Eingaben.istUhrzeit("08.15"));
    }
    @Test
    @DisplayName("Datum im Format JJJJ-MM-TT mit gültigem Monat und Tag")
    void datum() {
    assertTrue(Eingaben.istDatum("2026-10-21"));
    assertTrue(Eingaben.istDatum("2026-01-01"));
    assertTrue(Eingaben.istDatum("2026-12-31"));
    assertFalse(Eingaben.istDatum("2026-13-01"));
    assertFalse(Eingaben.istDatum("2026-00-10"));
    assertFalse(Eingaben.istDatum("2026-10-32"));
    assertFalse(Eingaben.istDatum("21.10.2026"));
    }
    }
  2. Die Logdatei auswerten: Lies anwendung.log Zeile für Zeile und zerlege jede Zeile mit einem Muster in Datum, Uhrzeit, Stufe, Bereich und Meldung. Zähle die Zeilen je Stufe (INFO, WARN, ERROR) und gib jeden Fehler mit Uhrzeit und Bereich aus. Zeilen, die nicht passen, zählen als „unlesbar“.

    Terminal-Fenster
    Fehler um 09:40:55 in Datenbank: Verbindung abgelehnt
    Fehler um 14:22:18 in Export: Datei auswertung.csv gesperrt
    Fehler um 16:20:31 in Datenbank: Zeitüberschreitung nach 30 s
    {ERROR=3, INFO=9, WARN=2}, unlesbar: 1
  3. Datenschutz: In der Logdatei stehen E-Mail-Adressen. Schreibe eine Kopie anwendung-anonym.log, in der jede Adresse durch *** ersetzt ist. Ein einfaches Muster genügt: Zeichen, @, Zeichen, Punkt, Zeichen.

  4. Für Schnelle: Eine Methode Zeitspanne.lies(text) liest Zeitspannen so großzügig, wie Menschen sie tippen – 8:00-16:15, 08:00 – 16:15, 7:45 -17:00 – und liefert die Dauer als Duration. Alles andere führt zu einer IllegalArgumentException.

Lösung

Beim Datum stecken die Regeln für Monat und Tag in Gruppen mit |: Ein Monat ist 0 mit 1 bis 9 oder 1 mit 0 bis 2. Ob der 31. im November existiert, prüft das Muster nicht – dafür ist LocalDate.parse da.

Eingaben.java
package de.drv.texte;
/** Stufe 1: Eingaben der Zeiterfassung prüfen. */
public class Eingaben {
/** Vier bis sechs Ziffern. */
public static boolean istPersonalnummer(String text) {
return text != null && text.matches("\\d{4,6}");
}
/** Eine Uhrzeit wie 08:15 – Stunden 00 bis 23, Minuten 00 bis 59. */
public static boolean istUhrzeit(String text) {
return text != null && text.matches("([01]\\d|2[0-3]):[0-5]\\d");
}
/** Ein Datum wie 2026-10-21 – Monat 01 bis 12, Tag 01 bis 31. */
public static boolean istDatum(String text) {
return text != null && text.matches("\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])");
}
}
Lösung
  • Das Muster für eine Zeile hat fünf Gruppen. teile.matches() prüft die ganze Zeile, danach stehen die Gruppen bereit. Die Zeile Absturzbericht folgt passt nicht und zählt als unlesbar.
  • In \[(\w+)\] sind die eckigen Klammern mit \ maskiert – sonst wären sie eine Zeichenklasse.
  • Das E-Mail-Muster ist bewusst einfach. Ein Muster, das alle gültigen Adressen erkennt, ist berüchtigt lang – für das Unkenntlichmachen reicht das hier.
Logauswertung.java
package de.drv.texte;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** Stufen 2 und 3: eine Logdatei auswerten und anonymisieren. */
public class Logauswertung {
// Datum, Uhrzeit, Stufe, [Bereich], Meldung – fünf Gruppen
private static final Pattern ZEILE =
Pattern.compile("(\\d{4}-\\d{2}-\\d{2}) (\\d{2}:\\d{2}:\\d{2}) (INFO|WARN|ERROR) \\[(\\w+)\\] (.*)");
// Etwas wie name@domain.de – bewusst einfach gehalten
private static final Pattern EMAIL = Pattern.compile("[\\w.-]+@[\\w-]+(\\.[\\w-]+)+");
public static void main(String[] args) throws IOException {
Map<String, Integer> proStufe = new TreeMap<>();
int unlesbar = 0;
Path quelle = Path.of("daten", "anwendung.log");
Path ziel = Path.of("daten", "anwendung-anonym.log");
try (BufferedReader leser = Files.newBufferedReader(quelle);
PrintWriter schreiber = new PrintWriter(Files.newBufferedWriter(ziel))) {
String zeile;
while ((zeile = leser.readLine()) != null) {
// Stufe 3: E-Mail-Adressen unkenntlich machen
schreiber.println(EMAIL.matcher(zeile).replaceAll("***"));
// Stufe 2: zerlegen und zählen
Matcher teile = ZEILE.matcher(zeile);
if (!teile.matches()) {
unlesbar++;
continue;
}
proStufe.merge(teile.group(3), 1, Integer::sum);
if (teile.group(3).equals("ERROR")) {
System.out.println("Fehler um " + teile.group(2) + " in " + teile.group(4) + ": " + teile.group(5));
}
}
}
System.out.println(proStufe + ", unlesbar: " + unlesbar);
System.out.println("Anonymisiert: " + ziel);
}
}
Lösung
Terminal-Fenster
"8:00-16:15" 8:15
"08:00 – 16:15" 8:15
" 7:45 -17:00 " 9:15
Keine Zeitspanne: 8 bis 16

\s* erlaubt Leerzeichen an jeder Stelle, [-–] einen Bindestrich oder einen Gedankenstrich, \d{1,2} ein- oder zweistellige Stunden.

Zeitspanne.java
package de.drv.texte;
import java.time.Duration;
import java.time.LocalTime;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/** Stufe 4: eine Zeitspanne wie "8:00 - 16:15" großzügig lesen. */
public class Zeitspanne {
// Stunden ein- oder zweistellig, Bindestrich oder Gedankenstrich, Leerzeichen erlaubt
private static final Pattern SPANNE = Pattern.compile("\\s*(\\d{1,2}):(\\d{2})\\s*[-–]\\s*(\\d{1,2}):(\\d{2})\\s*");
public static Duration lies(String text) {
Matcher teile = SPANNE.matcher(text);
if (!teile.matches()) {
throw new IllegalArgumentException("Keine Zeitspanne: " + text);
}
LocalTime von = LocalTime.of(Integer.parseInt(teile.group(1)), Integer.parseInt(teile.group(2)));
LocalTime bis = LocalTime.of(Integer.parseInt(teile.group(3)), Integer.parseInt(teile.group(4)));
return Duration.between(von, bis);
}
public static void main(String[] args) {
for (String text : new String[] {"8:00-16:15", "08:00 – 16:15", " 7:45 -17:00 ", "8 bis 16"}) {
try {
Duration dauer = lies(text);
System.out.printf("%-16s %d:%02d%n", "\"" + text + "\"", dauer.toHours(), dauer.toMinutesPart());
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
}
}
}