Reguläre Ausdrücke in Java – Java Regex Beispiel

Willkommen bei regulären Ausdrücken in Java. Es wird auch als Regex in Java bezeichnet. Als ich mit dem Programmieren begann, waren reguläre Ausdrücke in Java für mich ein Albtraum. Dieses Tutorial soll Ihnen helfen, reguläre Ausdrücke in Java zu beherrschen. Ich werde auch hierher zurückkommen, um mein Wissen über Java Regex aufzufrischen.

Reguläre Ausdrücke in Java

Der reguläre Ausdruck in Java definiert ein Muster für einen String. Reguläre Ausdrücke können zum Suchen, Bearbeiten oder Manipulieren von Text verwendet werden. Ein regulärer Ausdruck ist nicht sprachspezifisch, unterscheidet sich jedoch geringfügig für jede Sprache. Reguläre Ausdrücke in Java ähneln am meisten Perl. Java Regex-Klassen sind in dem Paket java.util.regex enthalten, das drei Klassen enthält:

1. Pattern: Das Pattern-Objekt ist die kompilierte Version des regulären Ausdrucks. Die Pattern-Klasse hat keinen öffentlichen Konstruktor und wir verwenden ihre öffentliche statische Methode compile, um das Pattern-Objekt zu erstellen, indem wir den regulären Ausdruck als Argument übergeben.
2. Matcher: Matcher ist das Java Regex-Engine-Objekt, das das Eingabezeichenfolgenmuster mit dem erstellten Musterobjekt abgleicht. Die Matcher-Klasse hat keinen öffentlichen Konstruktor, und wir erhalten ein Matcher-Objekt über die Musterobjekt matcher-Methode, die die Eingabezeichenfolge als Argument verwendet. Anschließend verwenden wir die matches-Methode, die basierend auf der Eingabezeichenfolge ein boolesches Ergebnis zurückgibt, ob sie dem Regex-Muster entspricht oder nicht.
3. PatternSyntaxException: PatternSyntaxException wird ausgelöst, wenn die Syntax des regulären Ausdrucks nicht korrekt ist.

Werfen wir einen Blick auf das Java Regex-Beispielprogramm.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// schlechter regulärer Ausdruck
		pattern = Pattern.compile("*xx*");

	}

}

Wenn wir dieses Java-Regex-Beispielprogramm ausführen, erhalten wir die folgende Ausgabe.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Da sich der Java-Regular-Ausdruck um Strings dreht, wurde die String-Klasse in Java 1.4 erweitert, um eine matches-Methode bereitzustellen, die das Regex-Musterabgleichen durchführt. Intern verwendet es die Java-Regex-Klassen Pattern und Matcher, um die Verarbeitung durchzuführen, aber offensichtlich reduziert es die Codezeilen. Die Pattern-Klasse enthält auch eine matches-Methode, die Regex und die Eingabezeichenfolge als Argumente verwendet und ein boolesches Ergebnis zurückgibt, nachdem sie abgeglichen wurden. Daher funktioniert der folgende Code gut, um die Eingabezeichenfolge mit einem regulären Ausdruck in Java abzugleichen.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Wenn Ihre Anforderung darin besteht, nur zu überprüfen, ob der Eingabestring mit dem Muster übereinstimmt, können Sie Zeit und Codezeilen sparen, indem Sie die einfache String-Matching-Methode verwenden. Sie sollten Pattern und Matches-Klassen nur dann verwenden, wenn Sie den Eingabestring manipulieren müssen oder das Muster wiederverwenden möchten. Beachten Sie, dass das von Regex definierte Muster auf den String von links nach rechts angewendet wird und sobald ein Quellenzeichen in einer Übereinstimmung verwendet wird, kann es nicht erneut verwendet werden. Zum Beispiel entspricht das Regex „121“ nur zweimal „31212142121“ als „_121____121“.

Reguläre Ausdrücke in Java – gängige Übereinstimmungssymbole

Java Regex-Metazeichen

In Java Regex gibt es einige Metazeichen, die wie Kurzcodes für häufige Übereinstimmungsmuster sind.

Es gibt zwei Möglichkeiten, Metazeichen als gewöhnliche Zeichen in regulären Ausdrücken zu verwenden.

1. Vorangestelltes Metazeichen mit einem Backslash (\).
2. Metazeichen innerhalb von \Q (das das Zitat beginnt) und \E (das es beendet) halten.

Reguläre Ausdrücke in Java – Quantifikatoren

Java Regex Quantifikatoren geben an, wie oft ein Zeichen übereinstimmen muss.

Java Regex Quantifikatoren können auch mit Zeichenklassen und Erfassungsgruppen verwendet werden. Zum Beispiel bedeutet [abc]+ – a, b oder c – einmal oder öfter. (abc)+ bedeutet die Gruppe „abc“ einmal oder öfter. Wir werden nun über Erfassungsgruppen sprechen.

Regulärer Ausdruck in Java – Erfassungsgruppen

Reguläre Ausdrücke in Java Erfassungsgruppen werden verwendet, um mehrere Zeichen als eine einzelne Einheit zu behandeln. Sie können eine Gruppe mit () erstellen. Der Teil des Eingabezeichens, der mit der Erfassungsgruppe übereinstimmt, wird im Speicher gespeichert und kann mit Backreference abgerufen werden. Sie können die Methode matcher.groupCount verwenden, um die Anzahl der Erfassungsgruppen in einem Java Regex-Muster zu ermitteln. Zum Beispiel enthält ((a)(bc)) 3 Erfassungsgruppen – ((a)(bc)), (a) und (bc). Sie können Backreference im regulären Ausdruck mit einem Backslash (\) und dann der Nummer der abzurufenden Gruppe verwenden. Erfassungsgruppen und Backreferences können verwirrend sein, also lassen Sie uns dies anhand eines Beispiels verstehen.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

Im ersten Beispiel wird beim ersten Laufzeit die erste Erfassungsgruppe (\w\d) verwendet, die sich zu „a2“ auswertet, wenn sie mit dem Eingabestring „a2a2“ übereinstimmt und im Speicher gespeichert wird. Daher bezieht sich \1 auf „a2“ und gibt daher true zurück. Aus dem gleichen Grund gibt die zweite Aussage false aus. Versuche, dieses Szenario für die Aussagen 3 und 4 selbst zu verstehen. 🙂 Jetzt werden wir uns einige wichtige Methoden der Klassen Pattern und Matcher ansehen.

1. Wir können ein Pattern-Objekt mit Flags erstellen. Zum Beispiel aktiviert Pattern.CASE_INSENSITIVE die Groß- und Kleinschreibung bei der Übereinstimmung.
2. Die Pattern-Klasse bietet auch die Methode split(String), die der Methode split() der String-Klasse ähnelt.
3. Die Methode toString() der Pattern-Klasse gibt den regulären Ausdrucksstring zurück, aus dem dieses Muster kompiliert wurde.
4. Die Matcher-Klassen verfügen über die Indexmethoden start() und end(), die genau zeigen, wo die Übereinstimmung im Eingabestring gefunden wurde.
5. Die Matcher-Klasse bietet auch Methoden zur Zeichenkettenmanipulation wie replaceAll(String replacement) und replaceFirst(String replacement).

Schauen wir uns diese Java Regex-Methoden anhand eines einfachen Beispielprogramms an.

package com.journaldev.util;

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

public class RegexExamples {

	public static void main(String[] args) {
		// Verwendung von Pattern mit Flags
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// Verwendung der Matcher find(), group(), start() und end() Methoden
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// Verwendung der Pattern split() Methode
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// Verwendung der Matcher.replaceFirst() und replaceAll() Methoden
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

Die Ausgabe des obigen Java-Regex-Beispielprogramms lautet.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

Das ist alles für reguläre Ausdrücke in Java. Java Regex scheint anfangs schwer zu sein, aber wenn Sie eine Weile damit arbeiten, ist es einfach zu lernen und zu verwenden.

Sie können den vollständigen Code und weitere Beispiele für reguläre Ausdrücke in unserem GitHub-Repository überprüfen.