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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einfache Muster lesen und schreiben
- mit
matchesprüfen, ob ein ganzer Text zu einem Muster passt - mit
PatternundMatcherStellen in einem Text finden und Teile herausholen - mit
replaceAllundsplitarbeiten
Demo-Code: 29-regex
⤓ demo-regex.zip herunterladenDer 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
Die Bausteine eines Musters
Abschnitt betitelt „Die Bausteine eines Musters“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.
Prüfen: matches
Abschnitt betitelt „Prüfen: matches“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"); } }
}Postleitzahl \d{5} 10115 passt 1011 passt nicht 1O115 passt nichtPersonalnummer \d{4,6} 4711 passt 123456 passt 47-11 passt nichtUhrzeit ([01]\d|2[0-3]):[0-5]\d 08:15 passt 23:59 passt 24:00 passt nicht 8:15 passt nichtName [A-ZÄÖÜ][a-zäöüß]+( [A-ZÄÖÜ][a-zäöüß]+)* Anna Muster passt anna passt nicht Jürgen Weiß passttext.matches(muster)prüft, ob der ganze Text zum Muster passt – nicht nur ein Teil davon.1O115passt 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
0oder1gefolgt von einer beliebigen Ziffer – oder2gefolgt von0bis3. Dann ein Doppelpunkt, dann0bis5und 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.
Finden: Pattern und Matcher
Abschnitt betitelt „Finden: Pattern und Matcher“Wer nicht den ganzen Text prüfen, sondern Stellen darin finden will, nimmt
zwei Klassen aus java.util.regex:
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)); }
}Datum 2026-10-19 an Stelle 23: Tag 19, Monat 10, Jahr 2026Datum 2026-10-23 an Stelle 42: Tag 23, Monat 10, Jahr 2026Betrag 650 € – Euro: 650Betrag 12,50 € – Euro: 12Die 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 | sPattern.compile(muster)übersetzt ein Muster einmal. Als Konstante ist es danach beliebig oft verwendbar – schneller alsmatches, das jedes Mal neu übersetzt.muster.matcher(text)liefert einenMatcherfür einen bestimmten Text. Jedesfind()sucht die nächste passende Stelle und sagt, ob es eine gab – daher diewhile-Schleife, wie beireadLineodernext.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.replaceAllersetzt jede Fundstelle. Im Ersatztext stehen$1,$2… für die Gruppen – so wird aus2026-10-19ein19.10.2026.splitnimmt ebenfalls ein Muster. Das[^a-zäöüß]+aus der Textstatistik heißt: Trenne an jeder Folge von Zeichen, die keine Buchstaben sind. Beim Apostroph ingeht'sfällt deshalb dassals 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.
Übung: Eingaben und eine Logdatei
Abschnitt betitelt „Übung: Eingaben und eine Logdatei“Im Demo-Projekt liegt die Datei daten\anwendung.log – das Protokoll einer
Zeiterfassung. Jede Zeile hat denselben Aufbau, bis auf eine:
2026-10-21 07:58:12 INFO [Start] Zeiterfassung gestartet, Version 1.42026-10-21 08:01:47 INFO [Anmeldung] anna.muster@example.org angemeldet2026-10-21 08:02:03 INFO [Erfassung] Beginn 08:00 für 4711 gespeichert2026-10-21 08:15:30 WARN [Datenbank] Verbindung langsam: 1840 ms-
Eingaben prüfen: Schreibe eine Klasse
Eingabenmit drei statischen Methoden, die jeweilstrueoderfalseliefern:istPersonalnummer(vier bis sechs Ziffern),istUhrzeit(wie08:15, immer zweistellig) undistDatum(wie2026-10-21, Monat 01 bis 12, Tag 01 bis 31).nullist 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"));}} -
Die Logdatei auswerten: Lies
anwendung.logZeile 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 abgelehntFehler um 14:22:18 in Export: Datei auswertung.csv gesperrtFehler um 16:20:31 in Datenbank: Zeitüberschreitung nach 30 s{ERROR=3, INFO=9, WARN=2}, unlesbar: 1 -
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. -
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 alsDuration. Alles andere führt zu einerIllegalArgumentException.
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.
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.
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
"8:00-16:15" 8:15"08:00 – 16:15" 8:15" 7:45 -17:00 " 9:15Keine Zeitspanne: 8 bis 16\s* erlaubt Leerzeichen an jeder Stelle, [-–] einen Bindestrich oder einen
Gedankenstrich, \d{1,2} ein- oder zweistellige Stunden.
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()); } } }
}