Java Academy · Lektion

Reguläre Ausdrücke mit Pattern und Matcher

Validieren Sie E-Mail-Adressen, extrahieren Sie Teilstrings und ersetzen Sie Muster mit Java-RegEx.

Reguläre Ausdrücke mit Pattern und Matcher ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Reguläre Ausdrücke mit Pattern und Matcher

Das Paket java.util.regex von Java stellt mit Pattern und Matcher leistungsfähige Funktionen zum Durchsuchen, Validieren, Extrahieren und Ersetzen von Text bereit.

Warum reguläre Ausdrücke?

Reguläre Ausdrücke (Regex) sind Muster zum Abgleichen von Text. In Java werden sie beispielsweise zur Validierung von E-Mail-Adressen und Telefonnummern, zum Extrahieren von Daten aus Protokollen und zum Parsen strukturierter Texte verwendet.

import java.util.regex.*;

// Is this a valid email?
String email = "alice@example.com";
boolean valid = email.matches("[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}");
System.out.println(valid); // true

// Extract version numbers from a string
String log = "App v1.2.3 deployed; api v2.0.0 started";
Pattern p = Pattern.compile("v(\\d+\\.\\d+\\.\\d+)");
Matcher m = p.matcher(log);
while (m.find()) System.out.println(m.group(1));
// 1.2.3 
// 2.0.0

Grundlagen der Regex-Syntax

Wichtige Regex-Metazeichen:

. – beliebiges Zeichen
\d – Ziffer; \w – Wortzeichen; \s – Leerraum
* – 0 oder mehr; + – 1 oder mehr; ? – 0 oder 1
{n,m} – zwischen n- und m-mal
^/$ – Anfang/Ende der Zeile
[abc] – Zeichenklasse

// In Java strings, backslash must be doubled: \d = "\\d"
Pattern digit   = Pattern.compile("\\d+");      // one or more digits
Pattern word    = Pattern.compile("\\w{3,20}");  // 3-20 word chars
Pattern space   = Pattern.compile("\\s+");       // whitespace
Pattern phone   = Pattern.compile("\\d{3}-\\d{3}-\\d{4}"); // 555-867-5309

System.out.println(digit.matcher("42").matches());       // true
System.out.println(phone.matcher("555-867-5309").matches()); // true

Pattern.compile und Matcher

Kompilieren Sie ein Pattern einmal und verwenden Sie den Matcher für mehrere Eingaben wieder – das ist effizienter, als String.matches() bei wiederholten Validierungen zu verwenden.

import java.util.regex.*;

Pattern emailPattern = Pattern.compile(
    "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,6}$"
);

String[] emails = {"alice@example.com", "bad@", "test.user@co.uk", "no-at-sign"};
for (String e : emails) {
    Matcher m = emailPattern.matcher(e);
    System.out.println(e + " -> " + (m.matches() ? "valid" : "invalid"));
}

find() im Vergleich zu matches()

matches() prüft den gesamten String. find() sucht das nächste Vorkommen innerhalb des Strings. Verwenden Sie find zum Suchen und matches für eine vollständige Validierung.

import java.util.regex.*;

Pattern price = Pattern.compile("\\d+\\.\\d{2}");

String invoice = "Total: 129.99, Tax: 10.40, Shipping: 5.00";
Matcher m = invoice.matcher(invoice);

// find() locates all matches
while (m.find()) {
    System.out.println("Found: " + m.group() + " at " + m.start());
}
// Found: 129.99 at 7
// Found: 10.40 at 20
// Found: 5.00 at 34

Erfassungsgruppen

Klammern erstellen Erfassungsgruppen. Verwenden Sie group(n), um die übereinstimmenden Teilstrings zu extrahieren.

import java.util.regex.*;

Pattern date = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = date.matcher("Deployed on 2024-06-15 and 2024-07-01");

while (m.find()) {
    String year  = m.group(1);
    String month = m.group(2);
    String day   = m.group(3);
    System.out.println(year + "/" + month + "/" + day);
}
// 2024/06/15
// 2024/07/01

Benannte Gruppen

Benannte Gruppen (?<name>...) machen Erfassungsgruppen übersichtlicher und ermöglichen den Zugriff über ihren Namen.

import java.util.regex.*;

Pattern log = Pattern.compile(
    "(?<timestamp>\\d{4}-\\d{2}-\\d{2}) (?<level>[A-Z]+) (?<message>.+)"
);

String line = "2024-06-15 ERROR Database connection failed";
Matcher m = log.matcher(line);

if (m.matches()) {
    System.out.println("Time: "    + m.group("timestamp"));
    System.out.println("Level: "   + m.group("level"));
    System.out.println("Message: " + m.group("message"));
}
// Time: 2024-06-15
// Level: ERROR
// Message: Database connection failed

replaceAll und replaceFirst

Pattern-basierte Ersetzung: Ersetzen Sie alle Vorkommen oder nur das erste.

import java.util.regex.*;

String text = "Call us at 123-456-7890 or 098-765-4321";

// Mask phone numbers for privacy logs
String masked = text.replaceAll("\\d{3}-\\d{3}-\\d{4}", "XXX-XXX-XXXX");
System.out.println(masked);
// Call us at XXX-XXX-XXXX or XXX-XXX-XXXX

// Replace multiple whitespace with single space
String cleaned = "too   many   spaces".replaceAll("\\s+", " ");
System.out.println(cleaned); // too many spaces

split() mit Regex

String.split() akzeptiert einen Regex. Verwenden Sie ihn, um an mehreren Trennzeichen oder komplexen Separatoren zu splitten.

// Split on comma with optional spaces
String csv = "Alice, Bob,  Charlie,Diana";
String[] names = csv.split("\\s*,\\s*");
for (String name : names) System.out.println("'" + name + "'");
// 'Alice' 'Bob' 'Charlie' 'Diana'

// Split on any whitespace
String words = "one  two\tthree  four";
String[] parts = words.split("\\s+");
System.out.println(parts.length); // 4

// Limit splits
String line = "key=value=extra";
String[] kv = line.split("=", 2); // [key, value=extra]

Pattern-Flags

Flags verändern das Verhalten von Regex: CASE_INSENSITIVE, MULTILINE, DOTALL.

import java.util.regex.*;

// Case-insensitive match
Pattern p = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);
System.out.println(p.matcher("HELLO World").find()); // true

// MULTILINE: ^ and $ match line boundaries
Pattern multi = Pattern.compile("^ERROR", Pattern.MULTILINE);
String logs = "INFO start\nERROR crash\nINFO end";
Matcher m = multi.matcher(logs);
int count = 0;
while (m.find()) count++;
System.out.println("ERROR lines: " + count); // 1

Praxisbeispiel: Log-Parser

Parsen von Apache-ähnlichen Zugriff protokollzeilen mit benannten Gruppen.

import java.util.regex.*;

Pattern accessLog = Pattern.compile(
    "(?<ip>[\\d.]+) - - \\[(?<time>[^\\]]+)\\] " +
    "\"(?<method>[A-Z]+) (?<path>[^ ]+)[^\"]*\" " +
    "(?<status>\\d{3}) (?<bytes>\\d+)"
);

String line = "192.168.1.1 - - [27/May/2024:10:30:00 +0000] \"GET /api/products HTTP/1.1\" 200 1024";
Matcher m = accessLog.matcher(line);
if (m.matches()) {
    System.out.println("IP: "     + m.group("ip"));
    System.out.println("Method: " + m.group("method"));
    System.out.println("Status: " + m.group("status"));
}

Kurzer Test

Was ist der Unterschied zwischen matches() und find() in Matcher?

Zusammenfassung: Reguläre Ausdrücke mit Pattern und Matcher

Wichtige Erkenntnisse:

Pattern.compile() kompiliert einen Regex; Matcher prüft ihn gegen Strings
matches() validiert den gesamten String; find() sucht nach Vorkommen
Erfassungsgruppen () extrahieren Teilstrings; der Zugriff erfolgt mit group(n) oder group("name")
Benannte Gruppen (?...) machen Patterns übersichtlicher
replaceAll() und split() akzeptieren Regex-Patterns für eine flexible Textverarbeitung
Verwenden Sie die Flags Pattern.CASE_INSENSITIVE, MULTILINE und DOTALL, um das Abgleichverhalten zu verändern

Häufig gestellte Fragen

Ist die Lektion „Reguläre Ausdrücke mit Pattern und Matcher“ kostenlos?

Ja — der vollständige Text von „Reguläre Ausdrücke mit Pattern und Matcher“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Reguläre Ausdrücke mit Pattern und Matcher“?

Validieren Sie E-Mail-Adressen, extrahieren Sie Teilstrings und ersetzen Sie Muster mit Java-RegEx. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Reguläre Ausdrücke mit Pattern und Matcher“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Unveränderlichkeit von String und der String-Pool
StringBuilder für effiziente Verkettung
Textblöcke und String.format
Reguläre Ausdrücke mit Pattern und Matcher

← Zurück zu Java Academy