Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 17 - Utility-Klassen II

## 17.1 Die Klasse StringTokenizer

- 17.1 Die Klasse StringTokenizer
  - 17.1.1 Anlegen eines StringTokenizers
  - 17.1.2 Zugriff auf Tokens

Die Klasse `StringTokenizer` ist eine nützliche Hilfsklasse, mit der Strings in einzelne Tokens zerlegt werden können. Ein Token wird dabei als zusammenhängende Sequenz von Zeichen angesehen, die durch Trennzeichen oder durch das Ende der Zeichenkette begrenzt ist. Die Klasse `StringTokenizer` implementiert das Interface `Enumeration`, so daß sie genauso benutzt werden kann wie die Iteratoren in den Klassen `Vector` oder `Hashtable`.

### 17.1.1 Anlegen eines StringTokenizers

Die Klasse `StringTokenizer` besitzt drei Konstruktoren:

    public StringTokenizer(String str)

    public StringTokenizer(String str, String delim)

    public StringTokenizer(String str,
                           String delim,
                           boolean returnTokens)
| java.util.StringTokenizer

Die erste Variante übergibt den String `str`, der tokenisiert werden soll, und bereitet das Objekt für die nachfolgenden Zugriffe auf die einzelnen Tokens vor. Die zweite Variante erwartet zusätzlich die Übergabe einer Zeichenkette `delim`, die alle Zeichen enthält, die als Trennzeichen zwischen zwei aufeinanderfolgenden Tokens angesehen werden sollen. In der Variante ohne `delim` werden die Zeichen `'\n'`, `'\r'`, `'\t'` und das Leerzeichen als Begrenzer verwendet.

Der dritte Konstruktor enthält einen weiteren Parameter, `returnTokens`. Wird er auf `true` gesetzt, geben die Funktionen zur Extraktion der Tokens auch die Trennzeichen zwischen zwei Tokens zurück. Falls der Parameter `false` ist, werden die Trennzeichen lediglich als Begrenzer angesehen, ohne an den Aufrufer zurückgegeben zu werden.

### 17.1.2 Zugriff auf Tokens

Wie beim Interface `Enumeration` üblich, erfolgt der Zugriff auf die Tokens mit Hilfe der Methoden `hasMoreElements` und `nextElement`:

    public boolean hasMoreElements()

    public Object nextElement()
      throws NoSuchElementException
| java.util.StringTokenizer

`hasMoreElements` gibt genau dann `true` zurück, wenn noch mindestens ein weiteres Token zur Verfügung steht, andernfalls wird `false` zurückgegeben. `nextElement` liefert das nächste Token, also den Teilstring von der aktuellen Position bis zum nächsten Trennzeichen bzw. bis zum Ende der Zeichenkette.

|  |  |  | Obwohl sehr elegant, ist die Verwendung der Methoden des Interfaces `Enumeration` leider etwas umständlich, weil `nextElement` Instanzen der Klasse `Object` zurückgibt. Um die Anwendung des `StringTokenizer` bequemer zu machen, existiert mit den Methoden `hasMoreTokens` und `nextToken` dieselbe Funktionalität noch einmal in einer Form, bei der ein Rückgabewert vom Typ `String` geliefert wird: |  |
Tip

    public boolean hasMoreTokens()

    public String nextToken()
      throws NoSuchElementException
| java.util.StringTokenizer

Hier liefert `nextToken` kein `Object`, sondern einen `String`, und eine explizite Typkonvertierung erübrigt sich damit.

Das folgende Programm verdeutlicht die Anwendung eines `StringTokenizer`, der eine einfache Zeichenkette in ihre Bestandteile zerlegt:

    001 /* Listing1701.java */
    002
    003 import java.util.*;
    004
    005 public class Listing1701
    006 {
    007   public static void main(String[] args)
    008   {
    009     String s = "Dies ist nur ein Test";
    010     StringTokenizer st = new StringTokenizer(s);
    011     while (st.hasMoreTokens()) {
    012       System.out.println(st.nextToken());
    013     }
    014   }
    015 }
| Listing1701.java

Listing 17.1: Anwendung der Klasse StringTokenizer

Die Programmausgabe ist:

    Dies
    ist
    nur
    ein
    Test

|  | In der Standardbibliothek des JDK gibt es noch einen zweiten Tokenizer, nämlich die Klasse `StreamTokenizer` aus dem Paket `java.io`. Im Gegensatz zum `StringTokenizer` arbeitet sie nicht mit Strings, sondern mit Streams (siehe Kapitel 18) und läßt sich umfangreicher konfigurieren. Sie kann zwischen Zahlen und Wortsymbolen unterscheiden und auf Wunsch Kommentare (in C/C++-Syntax) ignorieren. Mit ihrer Hilfe lassen sich Tokenizer für einfache Sprachen aufbauen. |  |
Hinweis

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de