Regular Expressions

Martin Kompf

Reguläre Ausdrücke (engl.: Regular Expressions, Abk.: regex) sind ein mächtiges Werkzeug zur Verarbeitung von Zeichenketten. In der Programmiersprache Java sind Regular Expressions seit Version 1.4 fest eingebaut. Diese Seite enthält eine Regex Kurzreferenz und einen Regex Tester zum interaktiven Testen von Regulären Ausdrücken.

Regex Tester

Der Regex Tester ist ein Java Programm zum interaktiven Entwickeln und Testen von Regular Expressions. Sie starten das Tool mittels Java Webstart durch Klick auf den Launch Button. Voraussetzung ist das Vorhandensein einer Java Laufzeitumgebung auf Ihrem Computer.

Neuere Versionen von Java Webstart erschweren oder verbieten die Ausführung unsignierter Anwendungen, selbst wenn diese komplett in der Sandbox laufen. In diesem Fall können Sie das Programm manuell downloaden und per Kommandozeile java -jar regexGUI.jar ausführen.

Die Signatur lässt sich mittels gpg --verify regexGUI.jar.sig.asc regexGUI.jar und meinem öffentlichen PGP-Key überprüfen.

Regex Kurzreferenz

x      Das Zeichen x
\\     Backslash
\xhh   Zeichen mit Hexadezimalwert hh
\uhhhh Unicodezeichen mit Hexcode hhhhh
\t     Tabulator
\n     Newline (LF)
\r     Carriage return (CR)

[abc]    a oder b oder c
[^abc]   Alles außer a, b oder c
[A-Z]    Alle Zeichen von A bis Z
[A-Za-z] A bis Z oder a bis z
[a-z&&[^mn]] a bis z außer m und n

.   Beliebiges Zeichen
\d  Alle Ziffern: [0-9]
\D  Alles außer Ziffern
\s  Whitespace: [ \t\n\x08\x0c\r]
\S  Negierung von \s
\w  Wortzeichen: [a-zA-Z_0-9]
\W  Negierung von \w

\p{Lower}  ASCII Kleinbuchstabe: [a-z]
\p{Upper}  ASCII Großbuchstabe: [A-Z]
\p{ASCII}  ASCII Zeichen: [\x00-\x7f]
\p{Alpha}  Buchstabe: [A-Za-z]
\p{Digit}  Ziffer: \d
\p{Alnum}  Buchstabe oder Ziffer

\p{Lu}  Unicode Großbuchstabe
\p{Ll}  Unicode Kleinbuchstabe
\p{Sc}  Unicode Währungssymbol
\p{Nl}  Unicode Zahl oder Buchstabe

^   Zeilenanfang
$   Zeilenende
\b  Wortgrenze
\A  Anfang der Eingabe
\z  Ende der Eingabe

?      einmal oder gar nicht
*      mehrmals oder gar nicht
+      mindestens einmal
{n}    exakt n-mal
{n,}   mindestens n-mal
{n,m}  n- bis m-mal

XY   X gefolgt von Y
X|Y  X oder Y
(X)  X als Gruppe

(?i)   Case-insensitive (ASCII)
(?iu)  Case-insensitive (Unicode)
(?m)   Multi-line mode
(?s)   Single-line / dotall mode

Anwendungsmuster von Regular Expressions in Java

String str = "X";
String regex = "[A-Z]"; 
// Test auf Großbuchstabe (ASCII)
boolean matches = str.matches(regex);

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
matches = matcher.matches();

// LookingAt
matcher = pattern.matcher("Hallo");
matches = matcher.matches(); // false
startsWith = matcher.lookingAt(); // true

String str = "17-25";
String regex = "(\\d+)-(\\d+)";
// Backslash im Java Sourcecode verdoppeln!
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
if (matcher.matches()) {
  System.out.printf("Von %s bis %s\n", 
    matcher.group(1), matcher.group(2));
}

String str = "1,2, 3, 4,   5,6";
String regex = "\\W+";
// Aufteilen an Wortgrenzen
String[] elements = str.split(regex);

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
elements = pattern.split(str);

String str = "Alle RDBMS benutzen SQL";
String regex = "\\p{Lu}{2,}";
// Finde all Wörter mit mindestens zwei 
// Großbuchstaben (Unicode)
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
while (matcher.find()) {
  System.out.println(str.substring(
    matcher.start(), matcher.end()));
}

String str = "value  with spaces";
String regex = "\\s+";
String replacement = "+";
// Ersetze whitespace mit +
String no_spaces = 
  str.replaceAll(regex, replacement);

// Alternative: pre-compiled pattern
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
no_spaces = matcher.replaceAll(replacement);

String str = "Hallo ${user.name}!";
String regex = "\\$\\{([a-z.]+)\\}";
// Ersetze ${name} mit System.getProperty(name)
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(str);
StringBuffer sb = new StringBuffer();
while (matcher.find()) {
  matcher.appendReplacement(sb, 
    System.getProperty(matcher.group(1)));
}
matcher.appendTail(sb);
System.out.println(sb.toString());

Links

• JavaDoc zur Package java.util.regex
• Ausführliche Pattern Syntax