RegEx

Kurz: Reguläre Ausdrücke — eine kompakte Mustersprache, um Text auf ein bestimmtes Format zu prüfen oder Teile daraus zu extrahieren. In Java über die Klassen Pattern und Matcher verfügbar.

Genauer: String bietet direkt einfache RegEx-Methoden wie matches(), replaceAll() und split(). Für wiederholte Nutzung desselben Musters lohnt sich Pattern.compile(regex) einmalig vorab, statt den Ausdruck bei jedem Aufruf neu zu parsen.

boolean gueltig = email.matches("^[\\w.-]+@[\\w.-]+\\.\\w+$");

Im Detail

String email = "test@example.com";
boolean gueltig = email.matches("^[\\w.-]+@[\\w.-]+\\.\\w+$");
 
// Wiederverwendbares Pattern - lohnt sich, wenn dasselbe Muster oft gebraucht wird
Pattern pattern = Pattern.compile("\\d+"); // eine oder mehrere Ziffern
Matcher matcher = pattern.matcher("Bestellung Nr. 12345 vom Kunden 987");
while (matcher.find()) {
    System.out.println(matcher.group()); // "12345", dann "987"
}
 
// Häufige Anwendungsfälle
String bereinigt = "Hallo   Welt".replaceAll("\\s+", " "); // mehrfache Leerzeichen -> eins
String[] teile = "a,b,,c".split(","); // {"a", "b", "", "c"}

Wichtige Escape-Regel: In einem Java-String muss ein Backslash selbst als \\ geschrieben werden, weil der Backslash schon in normalen Java-Strings eine Escape-Bedeutung hat (\n, \t, …) — ein RegEx-Muster wie \d+ (eine oder mehrere Ziffern) wird deshalb im Java-Quellcode zu "\\d+", was Anfänger häufig verwirrt, wenn sie RegEx-Beispiele aus anderen Sprachen übertragen. Pattern.compile() lohnt sich vor allem, wenn dasselbe Muster wiederholt genutzt wird (z. B. in einer Schleife), weil String.matches() intern bei JEDEM Aufruf das Pattern neu kompiliert — bei einmaliger Nutzung ist der direkte String-Methodenweg (matches, replaceAll, split) unkomplizierter.

Gruppen — Teile eines Treffers gezielt extrahieren

Klammern in einem Muster definieren “Gruppen”, die sich einzeln aus einem Treffer herauslösen lassen — besonders nützlich, um strukturierte Daten aus Text zu extrahieren:

Pattern datum = Pattern.compile("(\\d{2})\\.(\\d{2})\\.(\\d{4})"); // TT.MM.JJJJ
Matcher m = datum.matcher("Termin am 15.03.2026");
if (m.find()) {
    System.out.println("Tag: " + m.group(1));   // "15"
    System.out.println("Monat: " + m.group(2)); // "03"
    System.out.println("Jahr: " + m.group(3));  // "2026"
}

Seit Java 7 lassen sich Gruppen zusätzlich benennen ((?<jahr>\\d{4})), was den Zugriff per m.group("jahr") lesbarer macht als über nummerierte Positionen, die bei komplexeren Mustern leicht durcheinanderkommen.

Typische Fallstricke

Reguläre Ausdrücke sind mächtig, aber leicht falsch einzuschätzen: . matcht standardmäßig JEDES Zeichen außer einem Zeilenumbruch (nicht nur einen wörtlichen Punkt — dafür \\.), */+ sind standardmäßig “gierig” (matchen so viel wie möglich, nicht so wenig), was bei verschachtelten Strukturen wie HTML-Tags zu überraschenden Ergebnissen führen kann. Für strukturierte Formate wie HTML/XML/JSON gilt deshalb die Faustregel, lieber einen dedizierten Parser zu nutzen als RegEx zu verbiegen — RegEx eignet sich gut für einfache, flache Muster (E-Mail-Grobvalidierung, Ziffernfolgen extrahieren), aber schlecht für verschachtelte, rekursive Strukturen.

Siehe auch: Strings, Special Characters