15.6 Datenströme filtern und verketten

So wie im alltäglichen Leben Filter beim Kaffee oder bei Fotoapparaten eine große Rolle spielen, so sind sie auch bei Datenströmen zu finden. Immer dann, wenn Daten von einer Quelle gelesen oder in eine Senke geschrieben werden, können Filter die Daten auf dem Weg verändern. Die Java-Bibliothek sieht eine ganze Reihe von Filtern vor, die sich zwischen die Kommunikation schalten können.

Der CipherOutputStream stammt als Einziger aus dem Paket javax.crypto; manche Typen sind aus java.util.zip, und alle anderen stammen aus java.io.

15.6.1 Streams als Filter verketten (verschachteln)

Die Funktionalität der bisher vorgestellten Ein-/Ausgabe-Klassen reicht für den Alltag zwar aus, doch sind Ergänzungen gefordert, die die Fähigkeiten der Klassen erweitern; so zum Beispiel beim Puffern. Da die Programmlogik zur Pufferung mit Daten unabhängig von der Quelle ist, aus der die Daten stammen, findet sich die Pufferung in einer gesonderten Klasse. Java implementiert hier ein bekanntes Muster, das sich Dekorator nennt. Zwei Zeilen sollen dieses Prinzip verdeutlichen, um gepufferte Daten in eine Datei zu schreiben:

Writer fw = new FileWriter( filename );
Writer bw = new BufferedWriter( fw );

Der Konstruktor von BufferedWriter nimmt einen beliebigen anderen Writer auf, denn der Pufferung ist es egal, ob die Daten in eine Datei oder ins Netzwerk geschrieben werden. Das Prinzip ist also immer, dass der Filter einen anderen Strom annimmt, an den er die Daten weitergibt oder von dem er sie holt.

Schauen wir uns die Klassen im Paket java.io genau an, die andere Ströme im Konstruktor entgegennehmen:

• BufferedWriter, PrintWriter, FilterWriter nehmen Writer.
• BufferedReader, FilterReader, LineNumberReader, PushbackReader, StreamTokenizer nehmen Reader.
• BufferedOutputStream, DataOutputStream, FilterOutputStream, ObjectOutputStream, OutputStreamWriter, PrintStream, PrintWriter nehmen OutputStream.
• BufferedInputStream, DataInputStream, FilterInputStream, InputStreamReader, ObjectInputStream, PushbackInputStream nehmen InputStream.

15.6.2 Gepufferte Ausgaben mit BufferedWriter und BufferedOutputStream

Die Klassen BufferedWriter und BufferedOutputStream haben die Aufgabe, die mittels write() in den Ausgabestrom geleiteten Ausgaben zu puffern. Dies ist immer dann nützlich, wenn viele Schreiboperationen gemacht werden, denn das Puffern macht insbesondere Dateioperationen wesentlich schneller, da so mehrere Schreiboperationen zu einer zusammengefasst werden. Um die Funktionalität eines Puffers zu erhalten, besitzen die Klassen einen internen Puffer, in dem die Ausgaben von write() zwischengespeichert werden. Standardmäßig fasst der Puffer 8.192 Symbole. Er kann aber über einen parametrisierten Konstruktor auf einen anderen Wert gesetzt werden. Erst wenn der Puffer voll ist oder die Methoden flush() oder close() aufgerufen werden, werden die gepufferten Ausgaben geschrieben. Durch die Verringerung der Anzahl tatsächlicher write()-Aufrufe an das externe Gerät erhöht sich die Geschwindigkeit der Anwendung im Allgemeinen deutlich.

Abbildung 15.7: BufferedWriter ist ein Writer und dekoriert einen anderen Writer

Um einen BufferedWriter/BufferedOutputStream anzulegen, gibt es zwei Konstruktoren, denen ein bereits existierender Writer/OutputStream übergeben wird. An diesen Writer/OutputStream wird dann der Filter seinerseits die Ausgaben weiterleiten, insbesondere nach einem Aufruf von flush(), close() oder einem internen Überlauf.

class java.io.BufferedWriter     class java.io.BufferedOutputStream
extends Writer                   extends FilterOutputStream

• BufferedWriter(Writer out)
• BufferedOutputStream(OutputStream out)
  Erzeugt einen puffernden Ausgabestrom mit der Puffergröße von 8.192 Symbolen.
• BufferedWriter(Writer out, int sz)
• BufferedOutputStream(OutputStream out, int size)
  Erzeugt einen puffernden Ausgabestrom mit einer Puffergröße. Ist sie nicht echt größer 0, gibt es eine IllegalArgumentException.

Alle write()- und append()-Methoden sind so implementiert, dass die Daten erst im Puffer landen. Wenn der Puffer voll ist – oder flush() aufgerufen wird –, werden sie an den im Konstruktor übergebenen Writer durchgespült.

Beispiel zum BufferedWriter mit FileWriter und PrintWriter

Ein FileWriter sichert Daten in einer Datei. Ein BufferedWriter soll aber vorher die Daten erst einmal sammeln, sodass sie erst beim Flush an den FileWriter gehen. Der Anwendungsentwickler soll in unserem Beispiel aber nicht direkt den BufferedWriter nutzen, sondern ihn als allgemeinen Writer im Konstruktor von PrintWriter übergeben. Ein PrintWriter besitzt die komfortablen Methoden print(), println() und printf(), sodass wir nicht mehr nur auf write()-Methoden vom Writer angewiesen sind:

Listing 15.8: com/tutego/insel/io/writer/ChainedWriter.java, main()

PrintWriter pw = null;
try
{
  Writer fw = new FileWriter( "charArrayWriterDemoPuffer.txt" );
  Writer bw = new BufferedWriter( fw );
  pw = new PrintWriter( bw );

  for ( int i = 1; i < 10000; i++ )
    pw.println( "Zeile " + i );
}
catch ( IOException e ) {
  System.err.println( "Error creating file!" );
}
finally {
  if ( pw != null )
    pw.close();
}

Zusätzlich bietet die Klasse BufferedWriter die Methode newLine(), die in der Ausgabe eine neue Zeile beginnt. Das Zeichen für den Zeilenwechsel wird aus der Systemeigenschaft line.separator genommen. Da sie intern mit der write()-Methode arbeitet, kann sie eine IOException auslösen.

15.6.3 Gepufferte Eingaben mit BufferedReader/BufferedInputStream

Die Klassen BufferedReader und BufferedInputStream puffern Eingaben. Die Daten werden also zuerst in einen Zwischenspeicher geladen, was insbesondere bei Dateien zu weniger Zugriffen auf den Datenträger führt und so die Geschwindigkeit der Anwendung erhöht.

Die Klassen BufferedReader und BufferedInputStream besitzen je zwei Konstruktoren. Bei einem lässt sich die Größe des internen Puffers angeben. Die Puffergröße beträgt wie beim BufferedWriter/BufferedOutputStream standardmäßig 8.192 Einträge.

class java.io.BufferedReader     class java.io.BufferedInputStream
extends Reader                   extends FilterInputStream

• BufferedReader(Reader in)
• BufferedInputStream(InputStream in)
  Erzeugt einen puffernden Zeichenstrom mit der Puffergröße von 8.192.
• BufferedReader( Reader in, int sz )
• BufferedInputStream(InputStream in, int size)
  Erzeugt einen puffernden Zeichenstrom mit der gewünschten Puffergröße.

Programm zur Anzeige von Dateien

Das folgende Programm implementiert ein einfaches »cat«-Kommando[209](Der kurze Name »cat« stammt von »catenate«, einem Synonym für »concatenate«.) von Unix, um Dateiinhalte über die Standardausgabe auszugeben. Die Dateinamen werden auf der Kommandozeile übergeben:

Listing 15.9: com/tutego/insel/io/stream/cat.java

package com.tutego.insel.io.stream;

import java.io.*;

class cat
{
  public static void main( String[] args )
  {
    for ( String filename : args ) {
      try {
        InputStream in = new BufferedInputStream( new FileInputStream(filename) );

        try {
          for ( int c; (c = in.read()) != –1 /* EOF */; )
            System.out.write( c );
        }
        finally {
          in.close();
        }
      }
      catch ( IOException e ) {
        System.err.println( "cat: Fehler beim Verarbeiten von " + filename );
        System.exit( 1 );
      }
    } // end for
  }
}

Die Dateiangaben nimmt das Programm über die Kommandozeile entgegen; etwa so:

$ java com.tutego.insel.io.stream.cat adam.txt eva.txt

new FileReader(f) new BufferedReader(new FileReader(f))
new FileWriter(f) new BufferedWriter(new FileWriter(f))
new FileInputStream(f) new BufferedInputStream(new FileInputStream(f))
new FileOutputStream(f) new BufferedOutputStream(new FileOutputStream(f))

Zeilen lesen mit BufferedReader und readLine()

Die Klasse BufferedReader stellt die Methode readLine() zur Verfügung, die eine komplette Textzeile liest und als String an den Aufrufer zurückgibt; BufferedOutputStream als byte-orientierte Klasse bietet die Methode nicht an.

class java.io.BufferedReader
extends Reader

• String readLine()
  Liest eine Zeile bis zum Zeilenende und gibt den String ohne die Endzeichen zurück. Die Rückgabe ist null, wenn der Stream am Ende ist.

Da ein BufferedReader Markierungen und Sprünge erlaubt, werden die entsprechenden Methoden von Reader überschrieben.

Ihr Kommentar

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