Reguläre Ausdrücke in Java mit Beispielen: vollständige Anleitung

Reguläre Ausdrücke in Java mit Beispielen

Reguläre Ausdrücke (regex) sind ein leistungsstarkes Werkzeug zum Suchen, Extrahieren und Ersetzen von Text nach einem Muster. In Java wird die Arbeit mit regulären Ausdrücken über das Paket java.util.regex realisiert, das zwei Hauptklassen umfasst: Pattern (Muster) und Matcher (Vergleicher). In diesem Artikel werden wir die Syntax regulärer Ausdrücke, die Methoden zur Arbeit mit ihnen und praktische Beispiele in Java durchgehen.

1. Grundlagen der Syntax regulärer Ausdrücke

Ein regulärer Ausdruck gibt ein Muster zum Durchsuchen von Zeichenketten vor. Hier sind die grundlegenden Konstrukte:

• . — ein beliebiges Zeichen (außer Zeilenumbruch).
• \\d — eine Ziffer (0-9).
• \\w — ein Buchstabe, eine Ziffer oder ein Unterstrich (lateinisch).
• \\s — ein Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch).
• [abc] — eines der Zeichen a, b oder c.
• [^abc] — ein beliebiges Zeichen außer a, b, c.
• * — null oder mehr Wiederholungen.
• + — eine oder mehr Wiederholungen.
• ? — null oder eine Wiederholung.
• {n,m} — von n bis m Wiederholungen.
• ^ — Anfang der Zeichenkette.
• $ — Ende der Zeichenkette.
• | — logisches ODER.
• () — Erfassungsgruppe.

Escape-Sequenzen in Java: In Java-String-Literalen ist der umgekehrte Schrägstrich \\ ein Steuerzeichen. Um z.B. \\d an regex zu übergeben, muss man "\\\\d" schreiben. Für einen Punkt — "\\\\.".

2. Die Klassen Pattern und Matcher

Die Arbeit mit regulären Ausdrücken in Java beginnt mit der Kompilierung des Musters:

import java.util.regex.Pattern;import java.util.regex.Matcher;

public class RegexExample {    public static void main(String[] args) {        // Muster kompilieren        Pattern pattern = Pattern.compile("\\\\d+");        // Matcher für die Zeichenkette erstellen        Matcher matcher = pattern.matcher("Preis: 150 Rubel, Rabatt 20%");                // Alle Übereinstimmungen suchen        while (matcher.find()) {            System.out.println("Gefunden: " + matcher.group());        }    }}

Ausgabe:

Gefunden: 150Gefunden: 20

Wichtige Methoden von Matcher:

• find() — sucht die nächste Übereinstimmung (kann mehrmals aufgerufen werden).
• matches() — prüft, ob die gesamte Zeichenkette dem Muster entspricht (erfordert vollständige Übereinstimmung).
• lookingAt() — prüft, ob die Zeichenkette mit dem Muster beginnt.
• group() — gibt die gefundene Teilzeichenkette zurück (oder eine bestimmte Gruppe).
• groupCount() — Anzahl der Erfassungsgruppen.

3. Praktische Beispiele

3.1. Validierung einer E-Mail-Adresse

Wir prüfen, ob eine Zeichenkette eine gültige E-Mail ist (vereinfachte Version):

public class EmailValidator {    public static boolean isValidEmail(String email) {        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\\\.[a-zA-Z]{2,}$";        Pattern pattern = Pattern.compile(regex);        Matcher matcher = pattern.matcher(email);        return matcher.matches();    }

    public static void main(String[] args) {        System.out.println(isValidEmail("test@example.com")); // true        System.out.println(isValidEmail("invalid-email"));    // false    }}

Erklärung des Musters:

• ^[a-zA-Z0-9._%+-]+ — der lokale Teil (Buchstaben, Ziffern, Punkte, Unterstriche usw.).
• @ — das @-Zeichen.
• [a-zA-Z0-9.-]+ — die Domain (Buchstaben, Ziffern, Punkte, Bindestriche).
• \\\\.[a-zA-Z]{2,}$ — der Punkt und die Top-Level-Domain (mindestens 2 Zeichen).

3.2.