Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Mathematisches
6 Eigene Klassen schreiben
7 Angewandte Objektorientierung
8 Exceptions
9 Die Funktionsbibliothek
10 Threads und nebenläufige Programmierung
11 Raum und Zeit
12 Datenstrukturen und Algorithmen
13 Dateien und Datenströme
14 Die eXtensible Markup Language (XML)
15 Grafische Oberflächen mit Swing
16 Grafikprogrammierung
17 Netzwerkprogrammierung
18 Verteilte Programmierung mit RMI und Web-Services
19 JavaServer Pages und Servlets
20 Applets
21 Midlets und die Java ME
22 Datenbankmanagement mit JDBC
23 Reflection und Annotationen
24 Logging und Monitoring
25 Sicherheitskonzepte
26 Java Native Interface (JNI)
27 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Download: - ZIP, ca. 12,5 MB
Buch bestellen
Ihre Meinung?
<< zurück | Galileo Computing / <openbook> /Java-Insel | vor >>
Java ist auch eine Insel von Christian Ullenboom Programmieren mit der Java Standard Edition Version 6
Java ist auch eine Insel 7., aktualisierte Auflage geb., mit DVD (November 2007) 1.492 S., 49,90 Euro Galileo Computing ISBN 978-3-8362-1146-8 |
| 4 Der Umgang mit Zeichenketten
|  | 4.1 Einzelne Zeichen mit der Character-Klasse behandeln
|  | 4.2 Strings und deren Anwendung
|  |  | 4.2.1 String-Literale als String-Objekte für konstante Zeichenketten
|  |  | 4.2.2 String-Länge und Test auf Leerstring
|  |  | 4.2.3 Nach enthaltenen Zeichen und Zeichenfolgen suchen
|  |  | 4.2.4 Gut, dass wir verglichen haben
|  |  | 4.2.5 String-Teile extrahieren
|  |  | 4.2.6 Strings anhängen, Groß-/Kleinschreibung und Leerraum
|  |  | 4.2.7 Suchen und ersetzen
|  |  | 4.2.8 String-Objekte mit Konstruktoren neu anlegen
|  | 4.3 Konvertieren zwischen Primitiven und Strings
|  |  | 4.3.1 Unterschiedliche Typen in Zeichenketten konvertieren
|  |  | 4.3.2 String in primitives Element konvertieren
|  | 4.4 Veränderbare Zeichenketten mit StringBuffer/StringBuilder
|  |  | 4.4.1 Anlegen von StringBuffer/StringBuilder-Objekten
|  |  | 4.4.2 Die Länge eines StringBuffer/-Builder-Objekts
|  |  | 4.4.3 Daten anhängen
|  |  | 4.4.4 Zeichen(folgen) setzen, erfragen, löschen und umdrehen
|  |  | 4.4.5 Vergleichen von String/StringBuffer/StringBuilder
|  |  | 4.4.6 hashCode() bei StringBuffer/StringBuilder
|  | 4.5 Sprachabhängiges Vergleichen und Normalisierung
|  |  | 4.5.1 Die Klasse Collator
|  |  | 4.5.2 Effiziente interne Speicherung für die Sortierung
|  |  | 4.5.3 Normalisierung
|  | 4.6 Reguläre Ausdrücke
|  |  | 4.6.1 Die Klassen Pattern und Matcher
|  |  | 4.6.2 Mit MatchResult alle Ergebnisse einsammeln
|  | 4.7 Zerlegen von Zeichenketten
|  |  | 4.7.1 Splitten von Zeichenketten mit split()
|  |  | 4.7.2 split() in Pattern
|  |  | 4.7.3 Die Klasse Scanner
|  |  | 4.7.4 StringTokenizer
|  |  | 4.7.5 BreakIterator als Zeichen-, Wort-, Zeilen- und Satztrenner
|  | 4.8 Zeichenkodierungen und Base64
|  |  | 4.8.1 Über die Klasse String Kodierungen vornehmen
|  |  | 4.8.2 Konvertieren mit OutputStreamWriter-Klassen
|  |  | 4.8.3 Das Paket java.nio.charset
|  |  | 4.8.4 Base64-Kodierung
|  | 4.9 Formatieren von Ausgaben
|  |  | 4.9.1 Formatieren mit format() aus String
|  |  | 4.9.2 Die Format-Klassen im Überblick
|  |  | 4.9.3 Zahlen, Prozente und Währungen mit NumberFormat und DecimalFormat formatieren
|  |  | 4.9.4 Ausgaben mit MessageFormat formatieren
|  | 4.10 Zum Weiterlesen
## 4.6 Reguläre Ausdrücke Mit dem Paket java.util.regex lässt sich mithilfe der Klassen Matcher und Pattern eine Zeichenkette gegen ein Muster prüfen. Mit dieser leistungsfähigen Implementierung lässt sich die Funktionalität von Unix-Dienstprogrammen wie awk, sed, emacs, perl oder grep prinzipiell nachbilden. ### 4.6.1 Die Klassen Pattern und Matcher Im Prinzip besteht das Erkennen immer aus dem Aufbau eines regulären Ausdrucks und der Prüfung über die Klasse String oder Pattern: Listing 4.6 AHrefRegularExpression.java, main()
    String url = "<a href=\"www.tutego.com\">";
    boolean b  = String.matches( "<a href=.*>", url );     // true
Gleichwertig mit String.matches() ist Pattern.matches(). Der Punkt im regulären Ausdruck steht für ein beliebiges Zeichen, und der folgende Stern erlaubt wahllos viele beliebige Zeichen. Ein – hier nicht benutztes – vorgestelltes »\« maskiert das folgende Zeichen aus. #### Regeln für reguläre Ausdrücke Für reguläre Ausdrücke existieren eine ganze Menge von Regeln. Wichtige Quantifizierer für eine Zeichenkette X sind:
X? | X kommt einmal oder keinmal vor.
X* | X kommt keinmal oder beliebig oft vor.
X+ | X kommt einmal oder beliebig oft vor.
Die Bestandteile lassen sich zu Zeichenklassen zusammenfassen:
[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
Daneben gibt es vordefinierte Zeichenklassen. Die wichtigsten sind:
. | Jedes Zeichen
\d | Ziffer: [0-9]
\D | Keine Ziffer: [^0-9] bzw. [^\d]
\s | Weißraum: [ \t\n\x0B\f\r]
\S | Kein Weißraum: [^\s]
\w | Wortzeichen: [a-zA-Z0-9]
\W | Kein Wortzeichen: [^\w]
\p{Blank} | Leerzeichen oder Tab: [ \t]
\p{Lower}, \p{Upper} | Klein-/Großbuchstabe: [a-z] bzw. [A-Z]
\p{Punct} | Punkt-Zeichen: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Graph} | Sichtbares Zeichen: [\p{Alnum}\p{Punct}]
\p{Print} | Druckbare 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. #### Die Pattern-API Die einzelne Zeile lässt sich weiter zerlegen, denn String.matches() beziehungsweise Pattern.matches() ist nur eine Abkürzung für die Übersetzung eines Patterns und Anwendung von matches():
    Pattern p = Pattern.compile( "<a href=.*>" );
    Matcher m = p.matcher( "<a href=\"tutego.com\">" );
    boolean b = m.matches();
Hinweis Bei mehrmaliger Anwendung des gleichen Patterns sollte es compiliert bleiben, denn das Übersetzen kostet Speicher und Laufzeit. Es gibt Ausdrücke, die relativ zentral sind, wie zum Testen von E-Mail-Adressen, für die das interessant ist:
    static Pattern p = Pattern.compile( "[\\w|-]+@\\w[\\w|-]*\\.[a-z]{2,3}" );
Hier klicken, um das Bild zu vergrößern
    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. 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. ### 4.6.2 Mit MatchResult alle Ergebnisse einsammeln Die Schnittstelle java.util.regex.MatchResult deklariert Operationen, die Zugriff auf das Ergebnis (String, Start-, Endposition, Anzahl Gruppen) eines Matches ermöglichen. Ein Matcher-Objekt wird dafür mit toMatchResult() nach dem MatchResult-Objekt gefragt. Hier klicken, um das Bild zu vergrößern Ein einfaches Beispiel verdeutlicht die Arbeitsweise: Die eigene Utility-Funktion findMatches() soll für ein Muster und eine Zeichenkette alle Ergebnisse zurückliefern. Listing 4.7 MatchResultDemo.java, Teil 1
    public 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;
    }
Die Methode liefert ein einfaches Iterable zurück, was in unserem Beispiel ausreicht, um die Funktion 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, welche 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.8 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. ### Ihr Kommentar Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.
Name |
E-Mail |
Ihr Kommentar |
<< zurück | <top> | vor >>

Copyright © Galileo Press 2008
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.

[Galileo Computing]
Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de