Reguläre Ausdrücke in Java mit Regex

Ein regulärer Ausdruck ist eine Zeichenfolge, die ein Muster in einer Folge von Zeichen beschreibt. Sie können die API  Regex  for:
  • Validieren Sie eine Zeichenfolge und überprüfen Sie z. B. die Gültigkeit einer E-Mail oder eines Passworts.
  • Suche in a  Schnur;
  • Ersetzen Sie ein Muster oder einen Zeichensatz in einem String.
Die API java.util.regex hat eine einzige Schnittstelle und drei Klassen:
  • Pattern-Klasse: Eine kompilierte Darstellung eines regulären Ausdrucks. Um ein Muster zu erstellen, müssen Sie eine seiner Methoden aufrufen öffentliche statische Kompilierung,  , wodurch ein Pattern-Objekt zurückgegeben wird. Diese Methoden akzeptieren reguläre Ausdrücke als Argument.
  • Matcher-Klasse: Eine Mustersuchmaschine, die die Zeichenfolge analysiert. Sie rufen das Matcher-Objekt ab, indem Sie die Matcher-Methode im Pattern-Objekt aufrufen. Diese beiden Klassen arbeiten zusammen.
  • PatternSyntaxException: löst eine Ausnahme aus, wenn der reguläre Ausdruck ungültig ist.

Matcher class

Die Methoden der Matcher:
< td class="tg-031e">Finde den nächsten Ausdruck, der das Muster überprüft
Nr. Methode Beschreibung
1 boolean matches() gibt true zurück, wenn die Zeichenfolge ein Muster überprüft
2 boolean find()
3 boolean find(int start) Finde den nächsten Ausdruck, der das Muster von einem Startindex aus überprüft

Pattern class

Dies ist die kompilierte Version eines regulären Ausdrucks. Es wird für ein Muster oder Regex verwendet.

< td class="tg-031e">4
Nr. Methode Description
1 static Pattern compile(String regex) kompiliert den regulären Ausdruck und gibt eine Instanz von Pattern
2 Matcher matcher( CharSequence input) erstellt einen Matcher, der die Eingabesequenz analysiert
3 static boolean matches(String regex, CharSequence input) kompiliert und analysiert die Eingabesequenz.
String[] split(CharSequence c) gibt ein Array von Teilzeichenfolgen zurück, die mit dem Zeichen c
5 String pattern() gibt die Zeichenfolge für reguläre Ausdrücke zurück

Example

import java.util.regex.*; 

public class regexTest {

 public static void main(String args[]) {
 Muster p; 
 Matcher m;
 //Kompilierung des regulären Ausdrucks mit dem Muster: "a"
 p = Pattern.compile("a"); 
 //Erstellen und verknüpfen Sie die Engine mit dem regulären Ausdruck für die Zeichenfolge "ab"
 m = p.matcher("ab"); 
 //wenn das Muster gefunden wird
 if(m.find()) {
 System.out.println("Muster gefunden"); 
 }
 }
}
pattern found

Regular expression syntax

1- Metazeichen

Metazeichen sind Zeichen mit einer Bedeutung oder auf andere Weise, wie das Muster aufgebaut ist. Wenn Sie beispielsweise einem Metazeichen das Zeichen würde er vom Parser nicht interpretiert werden. Die von regulären Java-Ausdrücken unterstützten Metazeichen befinden sich in der folgenden Tabelle:

Zeichen Beschreibung
[ ] definiert einen Zeichensatz innerhalb eines
{ } Quantizer
\ Zeichen wird nicht als Metazeichen betrachtet
^ Zeilenanfang
$ Endline
| Operator OU
? 0 oder einmal der vorhergehende Ausdruck
* 0 oder mehr als einmal der vorhergehende Ausdruck
+ ein oder mehrere Male des vorherigen Ausdrucks
. Ersetzt ein beliebiges Zeichen

Beispiel: 

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

public class metaCharactersExample: {

 public static void main(String[] args) {
 System.out.println(
 Pattern.matches(".c", "abc"));//false (ersetzt nur a) 
 System.out.println(
 Pattern.matches(".. c", "abc"));//true (3. Zeichen ist c)
 System.out.println(
 Pattern.matches("... c", "abbc"));//true (4. Zeichen ist c)
 
 System.out.println(Pattern.matches("\\d", "2"));//true (nur eine Ziffer)
 System.out.println(Pattern.matches("\\d", "332"));//false (mehrere Ziffern) 
 System.out.println(Pattern.matches(
 "\\d","123abc"));//false (Ziffern und Zeichen)
 
 System.out.println(Pattern.matches(
 "\\D*",  "geek"));//true (Unverschlüsselt und erscheint mindestens einmal) 
 }
}
Der matches()zur Matcher- und Pattern-Klasse gehört, gibt sie true wenn das gesuchte Muster in der Zeichenkette vorhanden ist.

2- Zeichenklassen

Eine Zeichenklasse ist eine Zeichenmenge. Die Metazeichen [...] bezeichnet eine Zeichenklasse innerhalb eines regulären Ausdrucks. Sie können den Bereich mit dem Bindestrich '-'. Beispiel[0-9] stellt die Ziffern von 0 bis 9.

[abc] a, b oder c
[^abc] Negation: Ersetzt alle Alphabete außer a,b und c
[a-zA-Z] Bereich: Ersetzt alle Zeichen von a bis z und von A bis Z
[a-d[m-p]] Union: Ersetzt Zeichen von a bis d oder von m bis p: [a-dm-p]
[a-z& & [abc]] Schnittmenge: Ersetzt die gesamte Schnittmenge von a, b und c durch Zeichen von a bis z
[a-z& & [^cd]] Subtraktion: Ersetzt alle Zeichen von a bis z außer c und d: [abe-z]
[a-z& & [^m-p]] Subtraktion: von a bis z außer von m bis p: [a-lq-z]

Example

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

public class metaFeaturesExample: {

 public static void main(String[] args) {
 Muster p; 
 Matcher m;
 //alle Ziffern von 0 bis 9 außer 345
 p = Pattern.compile("[0-9& & [^345]]"); 
 m = p.matcher("7"); 
 boolescher Wert b = m.matches(); 
 System.out.println(b); 
 }
}
true

Vordefinierte Zeichenklassen

Dies sind die Klassen, die bereits in der Java:

Class Beschreibung
. Beliebiges Zeichen
\d Eine Zahl: [0-9]
\D Beliebiges Zeichen außer den Zahlen [^0-9]
\s Ein Leerzeichen: Zeilenumbruch, Leerzeichen: [ \t\n\x0B\f\r]
\S Ein nicht-weißes Zeichen: [^\s]
\w Ein Wortzeichen: [a-zA-Z_0-9]
\W Ein Zeichen, das kein Wort ist: [^\w]

Example

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

public class CharacterClassesExample{
 public static void main(String args[]) {
 //d: eine Ziffer 
 //+: 1 oder mehr Ziffern
 String regex = "\\d+"; 
 Muster p = Muster.compile(regex); 

 String-Phrase = "das Jahr 2015 21"; 
 
 Matcher m = p.matcher(Satz); 

 if (m.find()) {
 //show first group
 System.out.println("group 0:" + m.group(0)); 
 }
 }
}
group 0:2015
In diesem Beispiel wird der reguläre Ausdruck "\\d+" enthält zwei Schrägstriche, da man in Java immer ein '\ vorher. \d bedeutet den Bereich zwischen 0 und 9 Wenn Sie die '+ wird nur die erste gefundene Ziffer berücksichtigt: 2.

3-  Quantifizierer

Mit Quantizern können Sie festlegen, wie oft ein Zeichen wiederholt wird.

Quantizers Beschreibung
X? X kommt nur einmal vor
X+ Ein- oder mehrmals
X* null oder mehrfach
X{n} n mal
X{n, } n oder mehrmals
X{y,z} mindestens y mal, aber weniger als z mal

Examples

Motif String Results
[abc]? a a
[abc]? aa none
[abc]? ab none
a? abdaaaba {a}, { },{ },{a},{a},{a},{ },{a}
a* abdaaaba {a},{ },{ },{aa},{ },{a}
a+ abdaaaba {a}, {aaa},{a}
a[3] aaaa aaa
a{3, 6} aaaaaaaa aaaaaa
[0-9]{4} Der Jahr-2038-Fehler ähnelt dem Jahr-2000-Bug {2038}, {2000}

4- Capture-Gruppen

Capture-Gruppen bieten die Möglichkeit, mehrere Zeichen zu verarbeiten als einzelne Einheit oder Untermuster. Beispiel: (abc) erstellt eine einzelne Gruppe, die die Zeichen "a", "b" und "c".

Catch-Gruppen werden nach der Anzahl der Klammern gezählt, die von links nach rechts geöffnet werden. Im Ausdruck (A(B(C))) gibt es 4 Gruppen. Gruppe 0 enthält immer den gesamten Ausdruck:
  1. Gruppe 0: (A(B(C)))
  2. Gruppe 1:  (A)
  3. Gruppe 2:  (B(C))
  4. Gruppe 3:  (C)
Um in Java herauszufinden, wie viele Gruppen ein Ausdruck enthält, rufen Sie die Methode groupCount() des Matcher-Objekts. Die Methode groupCount() gibt einen int der die Gesamtzahl der Gruppen darstellt. Im folgenden Beispiel goupCount() würde die Zahl 4.

Die von der Gruppe erfasste Teilzeichenfolge wird von der group(int).

Beispiel 1:

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

public class Gruppe {

 public static void main(String[] args) {

 Muster p = Muster.compile("(A(B(C)))"); 
 Matcher m = p.matcher("ABC"); 
 if( m.matches())
 for(int i= 0; i<= m.groupCount(); ++i)
 System.out.println("group "+i+" :"+m.group(i)); 
 
 }
}
group 0:ABC
group 1:ABC
group 2:BC
group 3:C
Beispiel 2

Dieses Programm erstellt einen regulären Ausdruck, der eine Telefonnummer liest und auf ihre Gültigkeit prüft: 

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

public class regex_telephone {
 
 public static void main(String[] args) {
 
 String regex = "\\b(\\d{3})(\\d{4})(\\d{3})(\\d{3})\\b"; 
 Muster p = Muster.compile(regex); 
 String tel = "2541724156348"; 
 
 Matcher m = p.matcher(tel); 
 
 if (m.find()) {
 System.out.println("Phone: ("
 + m.group(1) + ") " + m.group(2) + "-" 
 + m.group(3) + "-" + m.group(4)); 
 } 
 }
}
Telefon: (254) 1724-156-348

5- Grenzen suchen

Sie können Ihr Muster präzisieren, indem Sie die Position des gesuchten Musters und dessen Ausgangspunkt angeben.

limiter Beschreibung
^ Beginning of Line
$ Endline
\b Word End.
\B Non-Word End.
\A Input Sequence Start
\ G Ende des vorherigen Vorkommens
\Z Ende der Sequenz, mit Ausnahme des letzten Zeichens
\z Ende der Sequenz

Examples

Motif String Ergebnisse
^java$ java java
\s*java$ java java
^hello\w* helloblahblah helloblahblah
\bjava\B javascript ist eine Programmiersprache java
\Gtest test test test
\btest\b Dies ist ein test test

Suchen Sie ein Muster und ersetzen Sie es

Die Regex-API bietet Ihnen die Möglichkeit, einen Text zu suchen und durch einen anderen zu ersetzen. In Java können Sie zwei Methoden der Matcher-Klasse verwenden, um diese Aufgabe zu erfüllen:
  • replaceFirst(String): Ersetzt nur das erste Vorkommen;
  • replaceAll(String): Iteriert und ersetzt alle Vorkommen.
Beispiel:

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

public class replacement {
 public static void main(String[] args) {
 Pattern p = Pattern.compile("bus"); 
 Matcher m = p.matcher("Ich reise mit dem Bus"); 
 String s = m.replaceAll("train"); 
 System.out.println(s); 
 }
}
Ich reise mit dem Zug
Referenzen:
Java Doc:  Reguläre Ausdrücke
JavaPoint:   Java Regex
TutorialsPoint:  Java - Reguläre Ausdrücke
Erweitern:  Reguläre Ausdrücke mit der Java