4.10 Reguläre Ausdrücke 

Mit dem Paket java.util.regex lässt sich mit Hilfe der Klassen Matcher und Pattern eine Zeichenkette gegen ein Muster prüfen. Mit dieser leistungsfähigen Implementierung lässt sich leicht die Funktionalität von Dienstprogrammen wie awk, sed, emacs, perl oder grep nachbilden.

Im Prinzip besteht das Erkennen immer aus dem Aufbau eines Pattern-Objekts mit dem regulären Ausdruck und der Prüfung:

Pattern p = Pattern.compile( "a*b" );
Matcher m = p.matcher( "aaaaab" );
boolean b = m.matches();

Die einzelnen Zeilen lassen sich auch zusammenfassen:

boolean b = Pattern.matches( "a*b", "aaaaab" );

Für reguläre Ausdrücke existieren eine ganze Menge von Regeln. Eine Übersicht findet sich in der API-Hilfe in der Klasse java.util.regex.Pattern. Widmen wir uns zunächst dem Funktionenangebot:

class java.util.regex.Pattern

static Pattern compile( String regex ) Übersetzt den regulären Ausdruck in ein Pattern-Objekt.

static Pattern compile( String regex, int flags ) Übersetzt den regulären Ausdruck in ein Pattern-Objekt mit Flags. Als Flags sind CASE_INSENSITIVE, MULTILINE, DOTALL, UNICODE_CASE und CANON_EQ erlaubt.

int flags() Liefert die Flags, nach denen geprüft wird.

Matcher matcher( CharSequence input ) Liefert ein Matcher-Objekt, das prüft.

static boolean matches( String regex, CharSequence input ) Liefert true, wenn der reguläre Ausdruck regex auf die Eingabe passt.

String pattern() Liefert den regulären Ausdruck, den das Pattern repräsentiert.

String[] split( CharSequence input ) Spaltet die Eingabesequenz auf.

String[] split( CharSequence input, int limit ) Spaltet die Eingabesequenz auf, liefert jedoch maximal begrenzt viele Teilzeichenfolgen.

Einige Methoden sind lediglich Abkürzungen. So macht der statische Aufruf Pattern. matches() nichts anderes, als ein Pattern zu compilieren:

Pattern.compile(regex).matcher(input).matches()

4.10.1 Splitten von Zeichenketten 

Mit der Funktion split() aus Pattern oder String kann eine Trennfolge definiert werden, die eine Zeichenkette in Teilzeichenketten zerlegt, ähnlich wie es der StringTokenizer macht. Der StringTokenizer ist jedoch beschränkt auf einzelne Zeichen als Trennsymbole, während die Methode split() einen regulären Ausdruck zur Beschreibung der Trennsymbole verwendet:

String[] split( CharSequence input ) Zerlegt die Zeichenfolge input in Teilzeichenketten, wie es das aktuelle Pattern-Objekt befiehlt.

String[] split( CharSequence input, int limit ) Wie split(CharSequence), nur durch limit begrenzt viele Teilzeichenketten.

Pattern p = Pattern.compile( "[/.-]" );

An die split()-Funktion übergeben wir als Parameter die Zeichenkette, die zerlegt werden soll. Werfen wir einen Blick auf ein Beispiel, welches die Felder in der Methode date() ausgibt:

Listing 4.8 SplitDemo.java

import java.util.regex.*;

public class SplitDemo
{
  public static void date( String fields[] )
  {
    for ( int i=0; i<fields.length; i++ )
      System.out.print( fields[i] + " " );
    System.out.println();
  }
  public static void main( String args[] )
  {
    Pattern p = Pattern.compile( "[/.-]" );
    date( p.split( "12-3-1973" ) );
    date( p.split( "12.3.1973" ) );
    date( p.split( "12/3/1973" ) );
  }
}

4.10.2 split() in String 

In der String-Klasse gibt es auch die Funktion split(). Sie ist eine Objektmethode, die die aktuelle Zeichenkette, die das String-Objekt repräsentiert, zerlegt. Diese Methode benötigt jetzt umgekehrt den regulären Ausdruck als Parameter. Die Implementierung delegiert jedoch die eigentliche Arbeit an das Pattern-Objekt:

public String[] split(String regex, int limit)
{
  return Pattern.compile(regex).split(this, limit);
}
public String[] split(String regex)
{
  return split(regex, 0);
}

class java.lang.String
implements CharSequence, Serializable

String[] split( String regex ) Zerlegt die aktuelle Zeichenkette mit dem regulären Ausdruck.

String[] split( String regex, int limit ) Zerlegt die aktuelle Zeichenkette mit dem regulären Ausdruck, liefert jedoch maximal begrenzt viele Teilzeichenfolgen.

4.10.3 Das Paket org.apache.regexp

Das org.apache.regexp-Paket ist eine Java-Implementierung der klassischen Bibliothek für reguläre Ausdrücke auf der Basis endlicher Automaten unter der BSD-Lizenz. Das Paket lässt sich unter http://jakarta.apache.org/regexp/ laden. Das Paket enthält wie üblich den kompletten Quellcode.