Einstieg in Java
Teil 6: Praktische Standardklassen

StreamTokenizer - Eingabe scheibchenweise

Für unsere Adresskartei führen wir ein selbsterklärendes Textdateiformat ein, mit dem sich die Daten auch leicht in anderen Programmen verwenden lassen. Textdateien haben außerdem den Vorteil, dass sie mit jedem normalen Editor bearbeitet werden können. In diesem Format füllt eine Adresse eine einzige Zeile, in der die Reihenfolge der Felder (z.B. Name, Adresse, Alter) beliebig ist. Außerdem dürfen Felder unbenutzt sein. Gültige Zeilen sehen dann so aus:

name='Graf Hardenberg' vorname = 'Otto'     alter=103
alter=1 vorname='Mathias'
name=         'Müller' vorname= 'Erika'
name='Müller' vorname='Martin' alter=45

Der StreamTokenizer erledigt die meistem dieser Anforderungen quasi standardmäßig. So werden Füllzeichen automatisch überlesen, Anführungszeichen erkannt und die enthaltenen Zeichenketten als Token zurückgeliefert. Sogar die gewünschten Kommentare sind frei verfügbar. (Übrigens werden sogar mehrzeilige Kommentare mit /* */ auf Wunsch erkannt und ausgeblendet.)

Erkennung des Zeilenendes	eolIsSignificant(false);
//-Kommentare	slashSlashComments(false);
/* */-Kommentare	slashStarComments(false);
Wort-Zeichen	wordChars('a', 'z'); wordChars('A', 'Z'); wordChars(128 + 32, 255);
Zwischenraumzeichen	whiteSpaceChars(0, ' ');
einzeiliger Kommentar	commentChar('/');
Anführungszeichen	quoteChar('\"'); quoteChar('\'');
Lesen von Zahlen	parseNumbers();

Tabelle 1: Standardvoreinstellung von StreamTokenizer

Der StreamTokenizer besitzt bestimmte standardisierte Voreinstellungen, die wir in Tabelle 1 zusammengestellt haben. Bevor wir nun den Eingabestrom mittels StreamTokenizer zerlegen, stellen wir noch diejenigen Parameter ein, die von den Standardwerten abweichen:

  void laden(InputStream is)
       throws IOException, InvalidAgeException
  {
    StreamTokenizer st = new StreamTokenizer(is);
    st.slashSlashComments(true);
    st.eolIsSignificant(true);
    st.whitespaceChars('=', '=');

Als nächstes können wir nun Token für Token aus dem Eingabestrom lesen. Beispielsweise ist durch unsere Voreinstellungen "name" oder "'Graf Hardenberg'" jeweils ein Token. Bild 1 zeigt, wie eine Zeile aus dem Eingabestrom in einzelne Tokens aufgebrochen wird. Wir empfangen die einzelnen Tokens in einer Schleife:

    int token;
    String nameNeu = "", vornameNeu = "";
    int alt = 0;
    boolean feldGelesen = false;
    do {
      token = st.nextToken();
      if (token == st.TT_WORD) {
	if ("name".equals(st.sval)) {
	  token = st.nextToken();
	  if (token == '\'') {
	    nameNeu = st.sval;
	    feldGelesen = true;
	  }
	}
	if ("vorname".equals(st.sval)) {
	  token = st.nextToken();
	  if (token == '\'') {
	    vornameNeu = st.sval;
	    feldGelesen = true;
	  }
	}
	if ("alter".equals(st.sval)) {
	  token = st.nextToken();
	  if (token == st.TT_NUMBER) {
	    alt = new Double(st.nval
                            ).intValue();
	    feldGelesen = true;
	  }
	}
      }
      if (  (   token == st.TT_EOL 
             || token == st.TT_EOF ) 
          && feldGelesen) { 
	Adresse adr = new Adresse(nameNeu
                       ,vornameNeu, alt);
	einfügen(adr);
	feldGelesen = false;
	nameNeu = "";
	vornameNeu = "";
	alt = 0;
      }
    } while (token != st.TT_EOF);
  }

Im Falle von token==st.TT_NUMBER wird eine Zahl erwartet. Da der StreamTokenizer Zahlen immer als Double liest, benutzen wir für die Umwandlung nach int den Ausdruck:

  new Double(st.nval).intValue();

Weil eine Adresse immer in einer einzigen Zeile stehen soll, signalisiert das Zeilenende (TT_EOL) den Beginn eines neuen Adressdatensatzes, falls zuvor mindestens ein Feld eingelesen worden ist. Fehlt eines der Adressfelder, so wird seine Voreinstellung "" in die Adresse übertragen.

Und schon haben wir eine flexible Einlesenmethode. Um das Gelesene in Dateien zu speichern, kommen noch zwei kleine Methoden hinzu, durch die Adressen und Karteien im Dateiformat abgelegt werden.

// neu in Klasse Adresse:
  void speichern(PrintStream ps)
       throws IOException
  {
    ps.println("name='" + name 
       + "' vorname='"+vorname
       +"' alter="+alter);
  }

// neu in Klasse Adresskartei:
  void speichern(PrintStream ps)
       throws IOException
  {
    for (Enumeration 
         e=adrTabelle.elements(); 
         e.hasMoreElements(); ) {   
      Object obj = e.nextElement();
      if (obj instanceof Adresse) {
	((Adresse)obj).speichern(ps);
      }
    }
  }    

Mit Hilfe von Enumeration werden Datensätze abgeholt und können dann mittels Methode nextElement() nacheinander aufgezählt werden, was ganz hilfreich für Schleifenkonstruktionen sein kann. Diese Aufzählungsklasse wird im übernächsten Abschnitt vorgestellt.

Hashtable: Schneller Zugriff auf Datensätze

class AdressKartei
{
  Hashtable adrTabelle;

  AdressKartei()      // Konstruktor
  { adrTabelle = new Hashtable(16); }

  void einfügen(Adresse adr)
  { adrTabelle.put(adr, adr); }

  void löschen(Adresse adr)
  throws ArrayIndexOutOfBoundsException
  { adrTabelle.remove(adr); }

  public boolean equals(Object obj)
  {
    if (obj instanceof Adresse) {
      Adresse a = (Adresse)obj;
      return (a.getKey()).equals(this.getKey());
    }
    return false;
  }

  public String getKey()
  { return name+vorname; }

Weiterhin erbt jedes Objekt eine Methode hashCode(), die ebenfalls von Hashtable benutzt wird. Wir überschreiben diese Methode in Klasse Adresse so, dass der Hashwert aus dem Schlüssel berechnet wird:

  public int hashCode() 
  { return (name+vorname).hashCode(); }

  Adresse key = new Adresse(name,vorname,0);
  if (kartei.contains(key)) 
    Adresse a = kartei.get(key);

Enumeration: Datenzugriff stückweise

public  interface  java.util.Enumeration
{
  public abstract boolean hasMoreElements();
  public abstract Object nextElement();     
}

  class A implements Enumeration

Das Interessante ist nun, dass sowohl Hashtable als Vector diese Schnittstelle implementieren. Dadurch können wir eine Schleife bauen, die die Inhalte sowohl einer Hashtabelle als auch eines Vektors ausliest. Dadurch sind wir in der Lage, einen Vektor gegen eine Hashtabelle auszutauschen, ohne den Schleifencode ändern zu müssen!

Wir hatten Enumeration bereits zuvor verwendet:

  for (Enumeration e=adrTabelle.elements();
       e.hasMoreElements(); )    {
    Object obj = e.nextElement();
    if (obj instanceof Adresse) 
      ((Adresse)obj).speichern(ps);
  }

Ausblick