Java - reguläre Ausdrücke

Willkommen, ambitionierte Java-Programmierer! Heute tauchen wir in die faszinierende Welt der regulären Ausdrücke (Regex) in Java ein. Keine Sorge, wenn Sie neu in der Programmierung sind; ich werde Sie auf dieser Reise Schritt für Schritt führen, genau wie ich es für unzählige Studenten in meinen Jahren des Unterrichtens getan habe. Also, holen Sie sich einen Kaffee und lassen Sie uns gemeinsam diese aufregende Abenteuer beginnen!

Was sind reguläre Ausdrücke?

Bevor wir in die javaspezifische Implementierung springen, lassen Sie uns verstehen, was reguläre Ausdrücke sind. Stellen Sie sich vor, Sie sind ein Detektiv, der versucht, ein spezifisches Muster in einem Meer aus Text zu finden. Genau das macht Regex – es ist ein leistungsstarkes Werkzeug für das Mustererkennung und die Manipulation von Zeichenketten.

Java-Reguläre Ausdrücke (Regex) Klassen

Java bietet ein Paket namens java.util.regex, das mehrere Klassen zur Arbeit mit regulären Ausdrücken enthält. Die drei Hauptklassen, auf die wir uns konzentrieren werden, sind:

1. Pattern
2. Matcher
3. PatternSyntaxException

Lassen Sie uns jede dieser Klassen im Detail erkunden.

Pattern-Klasse

Die Pattern-Klasse represents eine kompilierte Repräsentation eines regulären Ausdrucks. Denken Sie daran, es als die Bauplan für Ihre Mustererkennungs-Detektivarbeit.

import java.util.regex.Pattern;

public class PatternExample {
public static void main(String[] args) {
Pattern pattern = Pattern.compile("Hallo");
System.out.println("Pattern erstellt: " + pattern);
}
}

In diesem Beispiel erstellen wir ein einfaches Muster, das das Wort "Hallo" entspricht. Die compile()-Methode nimmt den regulären Ausdruck als Zeichenkette und gibt ein Pattern-Objekt zurück.

Matcher-Klasse

Die Matcher-Klasse ist der Ort, an dem die magische Arbeit wirklich stattfindet. Sie führt Match-Operationen auf einer Zeichenfolge basierend auf einem Pattern durch.

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

public class MatcherExample {
public static void main(String[] args) {
String text = "Hallo, Welt! Hallo, Java!";
Pattern pattern = Pattern.compile("Hallo");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
System.out.println("Treffer bei Index: " + matcher.start());
}
}
}

Dieser Code sucht nach dem Muster "Hallo" im gegebenen Text und druckt den Startindex jedes Treffers. Es ist, als würde unser Detektiv alle Vorkommen eines Hinweises in einem Dokument finden!

Syntax regulärer Ausdrücke

Nun lernen wir einige grundlegende Syntax für die Erstellung komplexerer Muster. Hier ist eine Tabelle der häufig verwendeten Metazeichen:

Metazeichen	Beschreibung
.	Stimmt mit jedem einzelnen Zeichen überein
^	Stimmt mit dem Beginn der Zeile überein
$	Stimmt mit dem Ende der Zeile überein
*	Stimmt mit null oder mehr Vorkommen überein
+	Stimmt mit einem oder mehr Vorkommen überein
?	Stimmt mit null oder einem Vorkommen überein
\d	Stimmt mit einer Ziffer überein
\s	Stimmt mit einem Leerzeichenzeichen überein
\w	Stimmt mit einem Wortzeichen (Buchstabe, Ziffer oder Unterstrich) überein

Lassen Sie uns einige davon in Aktion sehen:

public class RegexSyntaxExample {
public static void main(String[] args) {
String text = "Der schnelle braune Fuchs springt über den faulen Hund";

// Wörter, die mit 'q' beginnen, matchen
Pattern pattern1 = Pattern.compile("\\bq\\w+");
Matcher matcher1 = pattern1.matcher(text);
if (matcher1.find()) {
System.out.println("Wort, das mit 'q' beginnt: " + matcher1.group());
}

// Wörter, die mit 'g' enden, matchen
Pattern pattern2 = Pattern.compile("\\w+g\\b");
Matcher matcher2 = pattern2.matcher(text);
if (matcher2.find()) {
System.out.println("Wort, das mit 'g' endet: " + matcher2.group());
}
}
}

In diesem Beispiel verwenden wir \b, um Wortgrenzen zu matchen, \w+, um ein oder mehrere Wortzeichen zu matchen, und kombinieren sie mit 'q' und 'g', um Wörter zu finden, die mit 'q' und 'g' beginnen bzw. enden.

Capturing-Gruppen in regulären Ausdrücken

Capturing-Gruppen ermöglichen es Ihnen, mehrere Zeichen als einzelne Einheit zu behandeln. Sie werden erstellt, indem Sie die zu gruppierenden Zeichen in Klammern setzen.

public class CapturingGroupExample {
public static void main(String[] args) {
String text = "John Doe ([email protected])";
Pattern pattern = Pattern.compile("(\\w+)\\s(\\w+)\\s\\((\\w+@\\w+\\.\\w+)\\)");
Matcher matcher = pattern.matcher(text);

if (matcher.find()) {
System.out.println("Vorname: " + matcher.group(1));
System.out.println("Nachname: " + matcher.group(2));
System.out.println("E-Mail: " + matcher.group(3));
}
}
}

In diesem Beispiel extrahieren wir den Vornamen, Nachnamen und die E-Mail-Adresse einer Person aus einer Zeichenkette. Die Klammern im Muster erstellen Capturing-Gruppen, auf die wir mit matcher.group(n) zugreifen können.

Regulärer Ausdruck - Matcher-Klassenmethoden

Die Matcher-Klasse bietet mehrere nützliche Methoden. Hier sind einige der am häufigsten verwendeten:

Methode	Beschreibung
find()	Findet den nächsten Treffer für das Muster
group()	Gibt den gematchten Teilstring zurück
start()	Gibt den Startindex des Treffers zurück
end()	Gibt den Endindex des Treffers zurück
matches()	Überprüft, ob der gesamte String dem Muster entspricht

Lassen Sie uns diese Methoden in Aktion sehen:

public class MatcherMethodsExample {
public static void main(String[] args) {
String text = "Der Regen in Spanien fällt hauptsächlich auf die Ebene";
Pattern pattern = Pattern.compile("\\b\\w+ain\\b");
Matcher matcher = pattern.matcher(text);

while (matcher.find()) {
System.out.println("Gefunden: " + matcher.group());
System.out.println("Startindex: " + matcher.start());
System.out.println("Endindex: " + matcher.end());
}
}
}

Dieser Code findet alle Wörter, die auf "ain" enden, und druckt jeden Treffer zusammen mit seinen Start- und Endindices.

Regulärer Ausdruck - Ersetzungsmethoden

Reguläre Ausdrücke sind nicht nur zum Finden von Mustern geeignet; sie sind auch großartig zum Ersetzen von Text. Die Matcher-Klasse bietet Methoden für diesen Zweck:

public class ReplacementExample {
public static void main(String[] args) {
String text = "Der schnelle braune Fuchs springt über den faulen Hund";
Pattern pattern = Pattern.compile("Fuchs|Hund");
Matcher matcher = pattern.matcher(text);

String result = matcher.replaceAll("Tier");
System.out.println("Nach der Ersetzung: " + result);
}
}

In diesem Beispiel ersetzen wir sowohl "Fuchs" als auch "Hund" durch "Tier". Die replaceAll()-Methode erledigt die ganze harte Arbeit für uns!

Regulärer Ausdruck - PatternSyntaxException-Klasse

Manchmal können wir Fehler beim Schreiben unserer regulären Ausdrücke machen. Hier kommt die PatternSyntaxException-Klasse ins Spiel. Sie wird geworfen, um einen Syntaxfehler in einem regulären Ausdrucksmuster anzuzeigen.

public class PatternSyntaxExceptionExample {
public static void main(String[] args) {
try {
Pattern.compile("[");  // Ungültiger regex
} catch (PatternSyntaxException e) {
System.out.println("Pattern-Syntax-Ausnahme: " + e.getMessage());
System.out.println("Index des Fehlers: " + e.getIndex());
}
}
}

Dieser Code verwendet bewusst einen ungültigen regex, um zu demonstrieren, wie PatternSyntaxException funktioniert. Es ist, als hätte man einen eingebauten Korrekturleser für Ihre regulären Ausdrücke!

Und so, meine Freunde, haben wir unsere Reise durch die Welt der Java-Regulären Ausdrücke gemacht, von einfachen Mustern bis hin zu komplexen Ersetzungen. Denken Sie daran, wie jedes leistungsstarke Werkzeug, wird regex nützlicher, je mehr Sie damit üben. Also zögern Sie nicht, experimentieren und erstellen Sie Ihre eigenen Muster. Wer weiß? Sie könnten ja der Sherlock Holmes der Mustererkennung werden!

Fröhliches Coden, und möge Ihr String immer Ihren Erwartungen entsprechen!

Credits: Image by storyset