Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Imperative Sprachkonzepte
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Eigene Klassen schreiben
6 Exceptions
7 Äußere.innere Klassen
8 Besondere Klassen der Java SE
9 Generics<T>
10 Architektur, Design und angewandte Objektorientierung
11 Die Klassenbibliothek
12 Einführung in die nebenläufige Programmierung
13 Einführung in Datenstrukturen und Algorithmen
14 Einführung in grafische Oberflächen
15 Einführung in Dateien und Datenströme
16 Einführung in die <XML>-Verarbeitung mit Java
17 Einführung ins Datenbankmanagement mit JDBC
18 Bits und Bytes und Mathematisches
19 Die Werkzeuge des JDK
A Die Klassenbibliothek
Stichwort

Download:
- Aufgaben, ca. 1,1 MB
- Programme, ca. 12,8 MB

Buch bestellen
Ihre Meinung?

Spacer
Java ist auch eine Insel von Christian Ullenboom
Das umfassende Handbuch
Buch: Java ist auch eine Insel

Java ist auch eine Insel
Galileo Computing
1308 S., 10., aktualisierte Auflage, geb., mit DVD
ca. 49,90 Euro, ISBN 978-3-8362-1802-3
Pfeil 4 Der Umgang mit Zeichenketten
Pfeil 4.1 Von ASCII über ISO-8859-1 zu Unicode
Pfeil 4.1.1 ASCII
Pfeil 4.1.2 ISO/IEC 8859-1
Pfeil 4.1.3 Unicode
Pfeil 4.1.4 Unicode-Zeichenkodierung
Pfeil 4.1.5 Escape-Sequenzen/Fluchtsymbole
Pfeil 4.1.6 Schreibweise für Unicode-Zeichen und Unicode-Escapes
Pfeil 4.1.7 Unicode 4.0 und Java *
Pfeil 4.2 Die Character-Klasse
Pfeil 4.2.1 Ist das so?
Pfeil 4.2.2 Zeichen in Großbuchstaben/Kleinbuchstaben konvertieren
Pfeil 4.2.3 Ziffern einer Basis *
Pfeil 4.3 Zeichenfolgen
Pfeil 4.4 Die Klasse String und ihre Methoden
Pfeil 4.4.1 String-Literale als String-Objekte für konstante Zeichenketten
Pfeil 4.4.2 Konkatenation mit +
Pfeil 4.4.3 String-Länge und Test auf Leerstring
Pfeil 4.4.4 Zugriff auf ein bestimmtes Zeichen mit charAt( )
Pfeil 4.4.5 Nach enthaltenen Zeichen und Zeichenfolgen suchen
Pfeil 4.4.6 Das Hangman-Spiel
Pfeil 4.4.7 Gut, dass wir verglichen haben
Pfeil 4.4.8 Phonetische Vergleiche *
Pfeil 4.4.9 String-Teile extrahieren
Pfeil 4.4.10 Strings anhängen, Groß-/Kleinschreibung und Leerraum
Pfeil 4.4.11 Suchen und ersetzen
Pfeil 4.4.12 String-Objekte mit Konstruktoren neu anlegen *
Pfeil 4.5 Konvertieren zwischen Primitiven und Strings
Pfeil 4.5.1 Unterschiedliche Typen in String-Repräsentationen konvertieren
Pfeil 4.5.2 Stringinhalt in einen primitiven Wert konvertieren
Pfeil 4.5.3 String-Repräsentation im Format Binär, Hex, Oktal *
Pfeil 4.6 Veränderbare Zeichenketten mit StringBuilder und StringBuffer
Pfeil 4.6.1 Anlegen von StringBuilder/StringBuffer-Objekten
Pfeil 4.6.2 StringBuilder/StringBuffer in andere Zeichenkettenformate konvertieren
Pfeil 4.6.3 Zeichen(folgen) erfragen
Pfeil 4.6.4 Daten anhängen
Pfeil 4.6.5 Zeichen(folgen) setzen, löschen und umdrehen
Pfeil 4.6.6 Länge und Kapazität eines StringBuilder/StringBuffer-Objekts *
Pfeil 4.6.7 Vergleichen von String mit StringBuilder und StringBuffer
Pfeil 4.6.8 hashCode() bei StringBuilder/StringBuffer *
Pfeil 4.7 CharSequence als Basistyp *
Pfeil 4.8 Reguläre Ausdrücke
Pfeil 4.8.1 Pattern.matches() bzw. String#matches()
Pfeil 4.8.2 Die Klassen Pattern und Matcher
Pfeil 4.8.3 Finden und nicht matchen
Pfeil 4.8.4 Gierige und nicht gierige Operatoren *
Pfeil 4.8.5 Mit MatchResult alle Ergebnisse einsammeln *
Pfeil 4.8.6 Suchen und Ersetzen mit Mustern
Pfeil 4.8.7 Hangman Version 2
Pfeil 4.9 Zerlegen von Zeichenketten
Pfeil 4.9.1 Splitten von Zeichenketten mit split()
Pfeil 4.9.2 Die Klasse Scanner
Pfeil 4.9.3 Die Klasse StringTokenizer *
Pfeil 4.9.4 BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner *
Pfeil 4.10 Zeichenkodierungen, XML/HTML-Entitys, Base64 *
Pfeil 4.10.1 Unicode und 8-Bit-Abbildungen
Pfeil 4.10.2 Das Paket java.nio.charset und der Typ Charset
Pfeil 4.10.3 Konvertieren mit OutputStreamWriter/InputStreamReader-Klassen *
Pfeil 4.10.4 XML/HTML-Entitys ausmaskieren
Pfeil 4.10.5 Base64-Kodierung
Pfeil 4.11 Ausgaben formatieren
Pfeil 4.11.1 Formatieren und Ausgeben mit format()
Pfeil 4.11.2 Die Formatter-Klasse *
Pfeil 4.11.3 Formatieren mit Masken *
Pfeil 4.11.4 Format-Klassen
Pfeil 4.11.5 Zahlen, Prozente und Währungen mit NumberFormat und DecimalFormat formatieren *
Pfeil 4.11.6 MessageFormat und Pluralbildung mit ChoiceFormat
Pfeil 4.12 Sprachabhängiges Vergleichen und Normalisierung *
Pfeil 4.12.1 Die Klasse Collator
Pfeil 4.12.2 Effiziente interne Speicherung für die Sortierung
Pfeil 4.12.3 Normalisierung
Pfeil 4.13 Zum Weiterlesen

Rheinwerk Computing - Zum Seitenanfang

4.8 Reguläre AusdrückeZur nächsten Überschrift

Ein regulärer Ausdruck (engl. regular expression) ist eine Beschreibung eines Musters (engl. pattern). Reguläre Ausdrücke werden bei der Zeichenkettenverarbeitung beim Suchen und Ersetzen eingesetzt. Für folgende Szenarien bietet die Java-Bibliothek entsprechende Unterstützung an:

  • Frage nach einer kompletten Übereinstimmung: Passt eine Zeichenfolge komplett auf ein Muster? Wir nennen das match. Die Rückgabe einer solchen Anfrage ist einfach wahr oder falsch.
  • Finde Teilstrings: Das Pattern beschreibt einen Teilstring, und gesucht sind alle Vorkommen dieses Musters in einem Suchstring.
  • Ersetze Teilfolgen: Das Pattern beschreibt Wörter, die durch andere Wörter ersetzt werden.
  • Zerlegen einer Zeichenfolge: Das Muster steht für Trennzeichnen, sodass nach dem Zerlegen eine Sammlung von Zeichenfolgen entsteht.

Ein Pattern-Matcher ist die »Maschine«, die reguläre Ausdrücke verarbeitet. Zugriff auf diese Mustermaschine bietet die Klasse Matcher. Dazu kommt die Klasse Pattern, die die regulären Ausdrücke in einem vorcompilierten Format repräsentiert. Beide Klassen befinden sich im Paket java.util.regex. Um die Sache etwas zu vereinfachen, gibt es bei String zwei kleine Hilfsmethoden, die im Hintergrund auf die Klassen verweisen, um eine einfachere API anbieten zu können; diese nennen sich auch Fassaden-Methoden.


Rheinwerk Computing - Zum Seitenanfang

4.8.1 Pattern.matches() bzw. String#matches()Zur nächsten ÜberschriftZur vorigen Überschrift

Die statische Methode java.util.regex.Pattern.matches() und die Objektmethode matches() der Klasse String testen, ob ein regulärer Ausdruck eine Zeichenfolge komplett beschreibt.

Wir wollen testen, ob eine Zeichenfolge in einfache Hochkommata eingeschlossen ist:

Tabelle 4.10: Einfache reguläre Ausdrücke und ihr Ergebnis

Ausdruck Ergebnis
Pattern.matches( "'.*'", "'Hallo Welt'" ) true
"'Hallo Welt'".matches( "'.*'" ) true
Pattern.matches( "'.*'", "''" ) true
Pattern.matches( "'.*'", "Hallo Welt" ) false
Pattern.matches( "'.*'", "'Hallo Welt" ) false

Der Punkt im regulären Ausdruck steht für ein beliebiges Zeichen, und der folgende Stern ist ein Quantifizierer, der wahllos viele beliebige Zeichen erlaubt.

Regeln für reguläre Ausdrücke

Für reguläre Ausdrücke existiert eine ganze Menge von Regeln. Während die meisten Zeichen aus dem Alphabet erlaubt sind, besitzen Zeichen wie der Punkt, die Klammer, ein Sternchen und einige weitere Zeichen Sonderfunktionen. So maskiert auch ein vorangestelltes »\« das folgende Sonderzeichen aus, was bei besonderen Zeichen wie ».« oder »\« wichtig ist. Zunächst gilt es, die Anzahl an Wiederholungen zu bestimmen. Dazu dient ein Quantifizierer (auch Wiederholungsfaktor genannt). Drei wichtige gibt es. Für eine Zeichenkette X gilt:

Tabelle 4.11: Quantifizierer im Umgang mit einer Zeichenkette X

Quantifizierer Anzahl an Wiederholungen
X? X kommt einmal oder keinmal vor.
X* X kommt keinmal oder beliebig oft vor.
X+ X kommt einmal oder beliebig oft vor.

Eine Sonderform ist X(?!Y) – das drückt aus, dass der reguläre Ausdruck Y dem regulären Ausdruck X nicht folgen darf (die API-Dokumentation spricht von »zero-width negative lookahead«).

Tabelle 4.12: Beispiele für reguläre Ausdrücke mit Wiederholungen

Ausdruck Ergebnis
Pattern.matches( "0", "0" ) true
Pattern.matches( "0", "1" ) false
Pattern.matches( "0", "00" ) false
Pattern.matches( "0*", "0000" ) true
Pattern.matches( "0*", "01" ) false
Pattern.matches( "0\\*", "01" ) false
Pattern.matches( "0\\*", "0*" ) true

Da in regulären Ausdrücken oftmals ein Bereich von Zeichen, etwa alle Buchstaben, abgedeckt werden muss, gibt es die Möglichkeit, Zeichenklassen zu definieren.

Tabelle 4.13: Definition von Zeichenklassen

Zeichenklasse Enthält
[aeiuo] Zeichen a, e, i, o oder u
[^aeiuo] nicht die Zeichen a, e, i, o, u
[0-9a-fA-F] Zeichen 0, 1, 2, ..., 9 oder Groß-/Klein-Buchstaben a, b, c, d, e, f

Das »^« definiert negative Zeichenklassen, also Zeichen, die nicht vorkommen dürfen. Mit dem »-« lässt sich ein Bereich von Zeichen angeben.

Listing 4.12: RegExDemo.java, main(), Ausschnitt

System.out.println( Pattern.matches( "[01]*", "0" ) );           // true
System.out.println( Pattern.matches( "[01]*", "01001" ) ); // true
System.out.println( Pattern.matches( "[0123456789]*", "112" ) ); // true

Daneben gibt es vordefinierte Zeichenklassen, die in erster Linie Schreibarbeit ersparen. Die wichtigsten sind:

Tabelle 4.14: Vordefinierte Zeichenklassen

Zeichenklasse Enthält
. jedes Zeichen
\d Ziffer: [0-9]
\D keine Ziffer: [^0-9] beziehungsweise [^\d]
\s Weißraum: [ \t\n\x0B\f\r]
\S keinen Weißraum: [^\s]
\w Wortzeichen: [a-zA-Z_0-9]
\W keine Wortzeichen: [^\w]
\p{Blank} Leerzeichen oder Tab: [ \t]
\p{Lower}, \p{Upper} einen Klein-/Großbuchstaben: [a-z] beziehungsweise [A-Z]
\p{Alpha} einen Buchstaben: [\p{Lower}\p{Upper}]
\p{Alnum} ein alphanumerisches Zeichen: [\p{Alpha}\p{Digit}]
\p{Punct} ein Punkt-Zeichen: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} ein sichtbares Zeichen: [\p{Alnum}\p{Punct}]
\p{Print} ein druckbares Zeichen: [\p{Graph}]

Bei den Wortzeichen handelt es sich standardmäßig um die ASCII-Zeichen und nicht um deutsche Zeichen mit unseren Umlauten oder allgemeine Unicode-Zeichen. Eine umfassende Übersicht liefert die API-Dokumentation der Klasse java.util.regex.Pattern.

Listing 4.13: RegExDemo.java, main(), Ausschnitt

System.out.println( Pattern.matches( "\\d*", "112" ) );          // true
System.out.println( Pattern.matches( "\\d*", "112a" ) ); // false
System.out.println( Pattern.matches( "\\d*.", "112a" ) ); // true
System.out.println( Pattern.matches( ".\\d*.", "x112a" ) ); // true
Tipp

Die Methode contains() der String-Klasse testet nur Teilzeichenfolgen, aber diese Zeichenfolge ist kein regulärer Ausdruck (sonst würde so etwas wie contains(".") auch eine völlig andere Bedeutung haben). Wer ein s.contains("pattern") sucht, kann es als s.matches(".*pattern.*") umschreiben.


Rheinwerk Computing - Zum Seitenanfang

4.8.2 Die Klassen Pattern und MatcherZur nächsten ÜberschriftZur vorigen Überschrift

Der Aufruf der Objektmethode matches() auf einem String-Objekt beziehungsweise das statische Pattern.matches() ist nur eine Abkürzung für die Übersetzung eines Patterns und Anwendung von matches():

Tabelle 4.15: Implementierungen der beiden matches()-Methoden

String#matches() Pattern.matches()

public boolean
matches(String regex)
{
return Pattern.matches(regex, this);
}

public static boolean
matches(String regex, CharSequence input)
{
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(input);
return m.matches();
}

Während die String-Mitläufer-Methode matches() zur Pattern.matches() delegiert, steht hinter der statischen Fassadenmethode Pattern.matches() die wirkliche Nutzung der beiden zentralen Klassen Pattern für das Muster und Matcher für die Mustermaschine. Für unser erstes Beispiel Pattern.matches("'.*'", "'Hallo Welt'") hätten wir also äquivalent schreiben können:

Pattern p = Pattern.compile( "'.*'" );
Matcher m = p.matcher( "'Hallo Welt'" );
boolean b = m.matches();
Abbildung

Abbildung 4.6: UML-Diagramm von Pattern

Hinweis

Bei mehrmaliger Anwendung des gleichen Patterns sollte es compiliert gecacht werden, denn das immer wieder nötige Übersetzen über die Objektmethode String#matches() beziehungsweise die Klassenmethode Pattern.matches() kostet Speicher und Laufzeit.

final class java.util.regex.Pattern
implements Serializable
  • 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. In Java 7 kommt UNICODE_CHARACTER_CLASS hinzu.
  • 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.
  • static String quote(String s)
    Maskiert die Metazeichen/Escape-Sequenzen aus. So liefert Pattern.quote("*.[\\d") den String \Q*.[\d\E.
  • String pattern()
    Liefert den regulären Ausdruck, den das Pattern-Objekt repräsentiert.

Pattern-Flags *

Die Flags sind in speziellen Situationen ganz hilfreich, etwa wenn die Groß-/Kleinschreibung keine Rolle spielt oder sich die Suche über eine Zeile erstrecken soll. Doch Java zwingt uns nicht, die Pattern-Klasse zu nutzen, um die Flags einsetzen zu können, sondern erlaubt es, mit einer speziellen Schreibweise die Flags auch im regulären Ausdruck selbst anzugeben, was die Nutzung bei String#matches() ermöglicht.

Tabelle 4.16: Pattern-Flags

Flag in der Pattern-Klasse Eingebetteter Flag-Ausdruck
Pattern.CASE_INSENSITIVE (?i)
Pattern.COMMENTS (?x)
Pattern.MULTILINE (?m)
Pattern.DOTALL (?s)
Pattern.UNICODE_CASE (?u)
Pattern.UNICODE_CHARACTER_CLASS (?U)
Pattern.UNIX_LINES (?d)

In einem regulären Ausdruck sind die Varianten rechts sehr praktisch, da sie an unterschiedlichen Positionen ein- und ausgeschaltet werden können. Ein nach dem Fragezeichen platziertes Minus stellt die Option wieder ab, etwa "(?i)jetzt insensitive(?-i) wieder sensitive". Mehrere Flag-Ausdrücke lassen sich auch zusammensetzen, etwa zu "(?ims)".

In der Praxis häufiger im Einsatz sind Pattern.DOTALL/(?s), Pattern.CASE_INSENSITIVE/(?i) und Pattern.MULTILINE/(?m). Es folgen Beispiele, wobei wir MULTILINE bei den Wortgrenzen vorstellen.

Standardmäßig matcht der ».« kein Zeilenendezeichen, sodass ein regulärer Ausdruck einen Zeilenumbruch nicht erkennt. Das lässt sich mit Pattern.DOTALL-Flag beziehungsweise (?s) ändern.

Beispiel

Die Auswirkung vom DOTALL beziehungsweise(?s):

System.out.println( "wau  wau miau".matches( "wau.+wau.*" ) );      // true
System.out.println( "wau\nwau miau".matches( "wau.+wau.*" ) ); // false
System.out.println( "wau wau miau".matches( "(?s)wau.+wau.*" ) ); // true
System.out.println( "wau\nwau miau".matches( "(?s)wau.+wau.*" ) ); // true

Quantifizierer und Wiederholungen *

Neben den Quantifizierern ? (einmal oder keinmal), * (keinmal oder beliebig oft) und + (einmal oder beliebig oft) gibt es drei weitere Quantifizierer, die es erlauben, die Anzahl eines Vorkommens genauer zu beschreiben:

  • X{n}. X muss genau n-mal vorkommen.
  • X{n,}. X kommt mindestens n-mal vor.
  • X{n,m}. X kommt mindestens n-, aber maximal m-mal vor.
Beispiel

Eine E-Mail-Adresse endet mit einem Domain-Namen, der 2 oder 3 Zeichen lang ist:

Static Pattern p = Pattern.compile( "[\\w|-]+@\\w[\\w|-]*\\.[a-z]{2,3}" );

Ränder und Grenzen testen *

Die bisherigen Ausdrücke waren nicht ortsgebunden, sondern haben geprüft, ob es irgendwo im String eine Übereinstimmung gibt. Dateiendungen zum Beispiel sind aber – wie der Name schon sagt – am Ende zu prüfen, genauso wie ein URL-Protokoll wie »http://« am Anfang stehen muss. Um diese Anforderungen mit berücksichtigen zu können, können bestimme Positionen mit in einem regulären Ausdruck gefordert werden. Die Pattern-API erlaubt folgende Matcher:

Tabelle 4.17: Erlaubte Matcher

Matcher Bedeutung
^ Beginn einer Zeile
$ Ende einer Zeile
\b Wortgrenze
\B Keine Wortgrenze
\A Beginn der Eingabe
\Z Ende der Eingabe ohne Zeilenabschlusszeichen wie \n oder \r
\z Ende der Eingabe mit allen Zeilenabschlusszeichen
\G Ende des vorherigen Matches. Sehr speziell für iterative Suchvorgänge

Wichtig ist zu verstehen, dass diese Matcher keine »Breite« haben, also nicht wirklich ein Zeichen oder eine Zeichenfolge matchen, sondern lediglich die Position beschreiben.

Die Matcher ^ und $ lösen gut das Problem mit den Dateiendungen und HTTP-Protokollen und leisten gute Dienste bei bestimmten Löschanweisungen.

Beispiel

Die String-Methode trim() schneidet den Weißraum vorne und hinten ab. Mit replaceAll() und den Matchern für den Beginn und das Ende einer Zeile ist schnell
ein Ausdruck gefunden, der nur den Weißraum vorne oder nur hinten entfernt:

String s = " \tWo ist die Programmiersprache des Lächelns?\t\t  ";
String ltrim = s.replaceAll( "^\\s+", "" );
String rtrim = s.replaceAll( "\\s+$", "" );
System.out.printf( "'%s'%n", ltrim ); // 'Wo ist die Programmiersprache des
// Lächelns? '
System.out.printf( "'%s'%n", rtrim ); // ' Wo ist die Programmiersprache des
// Lächelns?'

Der Matcher \b ist nützlich, wenn es darum geht, ein Wort umrandet von Weißraum in einer Teilzeichenkette zu finden. In der Zeichenkette »Spaß in China innerhalb der Grenzen« wird die Suche nach »in« drei Fundstellen ergeben, aber \bin\b nur eine und \bin\B auch eine, und zwar »innerhalb«. Es matcht demnach ein \b genau die Stelle, bei der ein \w auf ein \W folgt (beziehungsweise andersherum).

Multiline-Modus *

Normalerweise sind ^ und $ nicht zeilenorientiert, das heißt, es ist ihnen egal, ob im String Zeilenumbruchzeichen wie \n oder \r vorkommen oder nicht. Mitunter soll der Test aber lokal auf einer Zeile stattfinden – hierzu muss der Multiline-Modus aktiviert werden.

Beispiel

Teste, ob eine E-Mail die Zeile »Hi,« enthält:

System.out.println( "Hi,".matches( ".*^Hi,$.*" ) );
System.out.println( "Fwd:\nHi,mir geht's gut!".matches( ".*^Hi,$.*" ) );
System.out.println( "Fwd:\nHi,\nmir geht's gut!".matches( "(?sm).*^Hi,$.*" ) );
Der Test auf ».*^Hi,$.*« gibt im ersten Fall true zurück, da der String wirklich matcht und wir auch überhaupt keinen Zeilentrenner haben, der uns Probleme bereiten könnte. Die zweite Zeile aber liefert false, da sie global mit »Fwd« und nicht mit »Hi« beginnt und mit »!« endet statt mit einem Komma. Führen wir den Test mit der Option (?sm) zeilenweise durch und überspringen wir die Zeilentrenner, dann ist das Ergebnis true, denn die 2. Zeile in
Fwd:
Hi,

mir geht’s gut!
passt genau auf unseren regulären Ausdruck.

Der Multiline-Modus erklärt auch den Grund, warum es gleich mehrere Grenz-Matcher gibt. Die Matches \A und \Z beziehungsweise \z sind im Prinzip wie ^ und $, unterscheiden sich aber dann, wenn der Multiline-Modus aktiviert ist. Dann arbeiten (wie im Beispiel) ^ und $ zeilenorientiert, \A und \Z beziehungsweise \z aber nie – die letzten drei Matcher kennen Zeilentrenner überhaupt nicht. Damit ist "Fwd:\nHi,\nalles OK!".matches("(?sm).*\\AHi,\\Z.*") auch trotz (?sm) ganz einfach false.

Es bleiben \z und \Z. Sie unterscheiden, ob bei Zeilen, die abschließende Zeilentrenner wie \n oder \r besitzen, diese Zeilentrenner mit zum Match gehören oder nicht. Das \z ist wie $ ein Matcher auf das absolute Ende inklusive aller Zeilentrenner. Das große \Z ignoriert am Ende stehende Zeilentrenner, sodass sozusagen der Match schon vorher zu Ende ist.

Beispiel

Das Trennzeichen beim split() soll einmal \z und einmal \Z sein:

String[] tokens1 = "Lena singt\r\n".split( "\\z" );
String[] tolens2 = "Lena singt\r\n".split( "\\Z" );
System.out.printf( "%d %s%n", tokens1.length, Arrays.toString( tokens1 ) );
System.out.printf( "%d %s%n", tolens2.length, Arrays.toString( tolens2 ) );
Bei \z gehören alle Zeilentrenner zum String, und daher ist die Ausgabe: 1 [Lena singt ] Die zweite Ausgabe ist:
2 [Lena singt,
]
Und die abschließenden Zeilentrenner sind ein zweites Token.


Rheinwerk Computing - Zum Seitenanfang

4.8.3 Finden und nicht matchenZur nächsten ÜberschriftZur vorigen Überschrift

Bisher haben wir mit regulären Ausdrücken lediglich festgestellt, ob eine Zeichenfolge vollständig auf ein Muster passt. Die Matcher-Klasse kann jedoch auch feststellen, ob sich eine durch ein Muster beschriebene Teilfolge im String befindet. Dazu dient die Methode find(). Sie hat zwei Aufgaben: Zunächst sucht sie nach einer Fundstelle und gibt bei Erfolg true zurück. Das Nächste ist, dass jedes Matcher-Objekt einen Zustand mit Fundstellen besitzt, den find() aktualisiert. Einem Matcher-Objekt entlockt die Methode group() den erkannten Substring, und start()/end() liefert die Positionen. Wiederholte Aufrufe von find() setzen die Positionen weiter:

Listing 4.14: RegExAllNumbers.java, main()

String s = "'Demnach, welcher verheiratet, der tut wohl; welcher aber " +
"nicht verheiratet, der tut besser.' 1. Korinther 7, 38";
Matcher matcher = Pattern.compile( "\\d+" ).matcher( s );
while ( matcher.find() )
System.out.printf( "%s an Position [%d,%d]%n",
matcher.group(),
matcher.start(), matcher.end() );

Die Ausgabe des Zahlenfinders ist:

1 an Position [94,95]
7 an Position [107,108]
38 an Position [110,112]
Beispiel

Da es in der String-Klasse zwar ein contains(), aber kein containsIgnoreCase() gibt, lässt sich für diesen Zweck entweder ein Ausdruck wie s1.toLowerCase().contains(
s2.toLowerCase())
formen oder ein Pattern-Flag verwenden:

String s1 = "Prince Michael I, Paris, Prince Michael II (Blanket)";
String s2 = "PARIS";
boolean in = Pattern.compile( Pattern.quote( s2 ),
Pattern.CASE_INSENSITIVE ).matcher( s1 ).find();
System.out.println( in ); // true


Rheinwerk Computing - Zum Seitenanfang

4.8.4 Gierige und nicht gierige Operatoren *Zur nächsten ÜberschriftZur vorigen Überschrift

Die drei Operatoren ?, * und + haben die Eigenschaft, die längste mögliche Zeichenfolge abzudecken – das nennt sich gierig (engl. greedy). Deutlich wird diese Eigenschaft bei dem Versuch, in einem HTML-String alle fett gesetzten Teile zu finden. Gesucht ist also ein Ausdruck, der im String

String string = "Echt <b>fett</b>. <b>Cool</b>!";

die Teilfolgen <b>fett</b> und <b>Cool</b> erkennt. Der erste Versuch für ein Programm könnte so aussehen:

Pattern pattern = Pattern.compile( "<b>.*</b>" );
Matcher matcher = pattern.matcher( string );
while ( matcher.find() )
System.out.println( matcher.group() );

Nun ist die Ausgabe aber <b>fett</b>. <b>Cool</b>! Das verwundert nicht, denn mit dem Wissen, dass * gierig ist, passt <b>.*</b> auf die Zeichenkette vom ersten <b> bis zum letzten </b>.

Die Lösung ist der Einsatz eines nicht gierigen Operators (auch genügsam, zurückhaltend, non-greedy oder reluctant genannt). In diesem Fall wird hinter den Qualifizierer einfach ein Fragezeichen gestellt.

Tabelle 4.18: Gierige und nicht gierige Operatoren

Gieriger Operator Nicht gieriger Operator
X? X??
X* X*?
X+ X+?
X{n} X{n}?
X{n,} X{n,}?
X{n,m} X{n,m}?

Mit diesem nicht gierigen Operator lösen wir einfach das Fettproblem:

Listing 4.15: RegExFindBold.java, main()

Pattern pattern = Pattern.compile( "<b>.*?</b>" );
Matcher matcher = pattern.matcher( "Echt <b>fett</b>. <b>Cool</b>!" );
while ( matcher.find() )
System.out.println( matcher.group() );

Wie gewünscht ist die Ausgabe:

<b>fett</b>
<b>Cool</b>

Rheinwerk Computing - Zum Seitenanfang

4.8.5 Mit MatchResult alle Ergebnisse einsammeln *Zur nächsten ÜberschriftZur vorigen Überschrift

Die Schnittstelle java.util.regex.MatchResult deklariert Operationen, die Zugriff auf das Ergebnis (String, Startposition, Endposition, Anzahl der Gruppen) eines Matches ermöglichen. Ein Matcher-Objekt wird dafür mit toMatchResult() nach dem MatchResult-Objekt gefragt.

Ein einfaches Beispiel verdeutlicht die Arbeitsweise: Die eigene statische Utility-Methode findMatches() soll für ein Muster und eine Zeichenkette alle Ergebnisse zurückliefern:

Listing 4.16: MatchResultDemo.java, Teil 1

static Iterable<MatchResult> findMatches( String pattern, CharSequence s )
{
List<MatchResult> results = new ArrayList<MatchResult>();

for ( Matcher m = Pattern.compile(pattern).matcher(s); m.find(); )
results.add( m.toMatchResult() );

return results;
}
Abbildung

Abbildung 4.7: Die Matcher-Klasse implementiert die MatcherResult-Schnittstelle.

Die Methode liefert ein einfaches Iterable zurück, was in unserem Beispiel ausreicht, um die Methode auf der rechten Seite des Doppelpunktes vom erweiterten for nutzen zu können. Vor dem Schleifendurchlauf übersetzt compile() den Muster-String in ein Pattern-Objekt, und matcher() gibt Zugang zum konkreten Mustererkenner, also Matcher-Objekt. Die Bedingung der Schleife ist so, dass pro Durchlauf ein Muster erkannt wird. Im Rumpf der Schleife sammelt die Ergebnisliste die MatchResult-Objekte, die die Funddaten repräsentieren. Nach Ablauf der Schleife liefert die Methode die gesammelten Objekte zurück.

Ein paar Programmzeilen zeigen schnell die Möglichkeiten. Ein einfaches Muster soll für ISBN-10-Nummern stehen – ohne Leerzeichen oder Bindestriche:

Listing 4.17: MatchResultDemo.java, Teil 2

String pattern = "\\d{9,10}[\\d|x|X]";
String s = "Insel: 3898425266, Reguläre Ausdrücke: 3897213494";

for ( MatchResult r : findMatches( pattern, s ) )
System.out.println( r.group() + " von " + r.start() + " bis " + r.end() );

Das Ergebnis auf der Konsole ist:

3898425266 von 7 bis 17
3897213494 von 39 bis 49

Die Informationen in einem MatchResult entsprechen also einem Zustand eines Matcher während des Parsens, genauer gesagt nach dem Erkennen einer Zeichenfolge. Daher implementiert auch die Klasse Matcher die Schnittstelle MatchResult.


Rheinwerk Computing - Zum Seitenanfang

4.8.6 Suchen und Ersetzen mit MusternZur nächsten ÜberschriftZur vorigen Überschrift

Von der Pattern/Matcher-Klasse haben wir bisher zwei Eigenschaften kennengelernt: zum einen, wie sie prüft, ob eine komplette Zeichenkette auf ein Muster passt, und zum anderen die Suchmöglichkeit, dass find() uns sagt, an welchen Stellen ein Muster in einer Zeichenkette vorkommt. Für den zweiten Fall gibt es noch eine Erweiterung, dass nämlich die Pattern-Klasse die Fundstellen nicht nur ermittelt, sondern sie auch durch etwas anderes ersetzen kann.

Beispiel

In einem String sollen alle Nicht-JVM-Sprachen ausgepiept werden:

String  text    = "Ich mag Java, Groovy und auch ObjectiveC und PHP.";
Matcher matcher = Pattern.compile("ObjectiveC|PHP" ).matcher( text );
StringBuffer sb = new StringBuffer();
while ( matcher.find() )
matcher.appendReplacement( sb, "[PIEP]" );
matcher.appendTail( sb );
System.out.println( sb ); // Ich mag Java, Groovy und auch [PIEP] und [PIEP].

Um mit dem Mechanismus »Suchen und Ersetzen« zu arbeiten, wird zunächst ein StringBuffer aufgebaut, denn in dem echten String kann Pattern die Fundstellen nicht ersetzen. Erkennt der Matcher ein Muster, ersetzt appendReplacement() es durch eine Alternative, die in den StringBuffer kommt. So wächst der StringBuffer von Schritt zu Schritt. Nach der letzten Fundstelle setzt appendTail() das noch verbleibende Teilstück an den StringBuffer.

Toll an appendReplacement() ist, dass die Ersetzung nicht einfach nur ein einfacher String ist, sondern dass er mit $ Zugriff auf die Suchgruppe hat. Damit lassen sich sehr elegante Lösungen bauen. Nehmen wir an, wir müssen in einer Zeichenkette alle URLs in HTML-Hyperlinks konvertieren. Dann rahmen wir einfach jede Fundstelle in die nötigen HTML-Tags ein. In Quellcode sieht das so aus:

Listing 4.18: RegExSearchAndReplace.java, main()

String  text    = "Hi, schau mal bei http://stackoverflow.com/ " +
"oder http://www.tutego.de/ vorbei.";
String regex = "http://[a-zA-Z0-9\\-\\.]+\\.[a-zA-Z]{2,3}(\\S*)?";
Matcher matcher = Pattern.compile( regex ).matcher( text );
StringBuffer sb = new StringBuffer( text.length() );

while ( matcher.find() )
matcher.appendReplacement( sb, "<a href=\"$0\">$0</a>" );

matcher.appendTail( sb );

System.out.println( sb );

Der StringBuffer enthält dann zum Schluss "Hi, schau mal bei <a href="http://stackoverflow.com/">http://stackoverflow.com/</a> oder <a href="http://www.tutego.de/">http://www.tutego.de/</a> vorbei." (Der gewählte reguläre Ausdruck für URLs ist kurz, aber nicht vollständig. Für das Beispiel spielt das aber keine Rolle.)

Hinweis

Der Ersetzungsausdruck "<a href=\"$0\">$0</a>" enthält mit $ Steuerzeichen für den Matcher. Wenn die Ersetzung aber überhaupt nicht mit $n auf das gefundene Wort zurückgreift, sollten die beiden Sonderzeichen \ und $ ausmaskiert werden. Auf diese Weise werden merkwürdige Fehler vermeiden, wenn doch in der Ersetzung ein Dollar oder Backslash vorkommt. Das Ausmaskieren übernimmt die Methode quoteReplacement(), sodass sich zum Beispiel Folgendes ergibt:

matcher.appendReplacement( sb, Matcher.quoteReplacement( replacement ) );


Rheinwerk Computing - Zum Seitenanfang

4.8.7 Hangman Version 2Zur vorigen Überschrift

Mit regulären Ausdücken lässt sich eine ganz spezielle Aufgabe unseres Hangman-Spiels noch verbessern. Wir hatten die Aufgabe, dass ungeratene Zeichen durch einen Unterstrich ersetzt werden. Diese Ersetzung kann sehr gut replaceAll() übernehmen.

Listing 4.19: Hangman2.java

import java.util.*;

public class Hangman2
{
public static void main( String[] args )
{
List<String> hangmanWords = Arrays.asList( "samoa", "tonga", "fiji", "vanuatu" );
Collections.shuffle( hangmanWords );

String hangmanWord = hangmanWords.get( 0 );
String usedChars = "";
String guessedWord = hangmanWord.replaceAll( ".", "_" );

for ( int guesses = 1; ; )
{
if ( guesses == 10 )
{
System.out.printf( "Nach 10 Versuchen ist jetzt Schluss. Sorry! Apropos,
das Wort war '%s'.", hangmanWord );
break;
}

System.out.printf( "Runde %d. Bisher geraten: %s. Was wählst du für ein
Zeichen?%n", guesses, guessedWord );
char c = new java.util.Scanner( System.in ).next().charAt( 0 );
if ( usedChars.indexOf( c ) >= 0 )
{
System.out.printf( "%c hast du schon mal getippt!%n", c );
guesses++;
}
else // Zeichen wurde noch nicht benutzt
{
usedChars += c;
if ( hangmanWord.indexOf( c ) >= 0 )
{
guessedWord = hangmanWord.replaceAll( "[^"+usedChars+"]", "_" );
if ( guessedWord.contains( "_" ) )
System.out.printf( "Gut geraten, '%s' gibt es im Wort. Aber es
fehlt noch was!%n", c );
else
{
System.out.printf( "Gratulation, du hast das Wort '%s' erraten!",
hangmanWord );
break;
}
}
else // hangmanWord.indexOf( c ) == –1
{
System.out.printf( "Pech gehabt, %c kommt im Wort nicht vor!%n", c );
guesses++;
}
}
}
}
}


Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.

>> Zum Feedback-Formular
<< zurück
  Zum Katalog
Zum Katalog: Java ist auch eine Insel





Java ist auch eine Insel
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Katalog: Java SE Bibliotheken






 Java SE Bibliotheken


Zum Katalog: Professionell entwickeln mit Java EE 7






 Professionell
 entwickeln mit
 Java EE 7


Zum Katalog: Einstieg in Eclipse






 Einstieg in
 Eclipse


Zum Katalog: Einstieg in Java






 Einstieg in
 Java


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2011
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de