12.6 Besondere OutputStream- und InputStream-Klassen 

Neben den Filter-Klassen und den Klassen, die in eine Ressource wie eine Datei schreiben, gibt es weitere Klassen, die wichtig sind. Dazu zählen

ByteArrayOutputStream. Schreibe Binärdaten in ein Byte-Feld.

ByteArrayInputStream. Liest Daten aus einem Byte-Feld.

SequenceInputStream. Legt mehrere Eingabeströme zu einem großen zusammen.

PipedOutputStream/PipedInputStream. Ermöglicht Thread-Kommunikation.

ObjectOutputStream/ObjectInputStream. Ermöglichkeit Schreiben und Lesen von Objektzuständen.

Alle aufgeführten Klassen sind keine Filter, da sie keine Transformationen vornehmen und diese weiterleiten.

12.6.1 Bytes in den Strom schreiben mit ByteArrayOutputStream 

Die Klasse ByteArrayOutputStream lässt sich gut verwenden, wenn mehrere unterschiedliche primitive Datentypen in ein Bytefeld kopiert werden sollen, die dann später eventuell binär weiterkodiert werden müssen. Erstellen wir etwa eine GIF-Datei¹  , so müssen wir nacheinander verschiedene Angaben schreiben. So erstellen wir leicht eine Grafikdatei im Speicher. Anschließend konvertieren wir mit toByteArray() den Inhalt des Datenstroms in ein Bytefeld.

ByteArrayOutputStream boas =   new ByteArrayOutputStream();  
DataOutputStream out = new DataOutputStream( boas );

// Header

out.write( ’G’ ); out.write( ’I’ ); out.write( ’F’ );
out.write( ’8’ ); out.write( ’9’ ); out.write( ’a’ );

// Logical Screen Descriptor

out.writeShort( 128 );   // Logical Screen Width (Unsigned)
out.writeShort( 37 );    // Logical Screen Height (Unsigned)

// <Packed Fields>, Background Color Index, Pixel Aspect Ratio
// und so weiter.

out.close();

byte result[] = boas.toByteArray();

class java.io.ByteArrayOutputStream
extends OutputStream

ByteArrayOutputStream() Erzeugt ein neues OutputStream-Objekt, welches die Daten in einem Bytefeld abbildet.

ByteArrayOutputStream( int size ) Erzeugt ein ByteArrayOutputStream mit einer gewünschten Pufferkapazität.

Mit die wichtigste Methode ist toByteArray(), die ein byte[] mit den geschriebenen Inhalt liefert. reset() löscht den internen Puffer. Eine praktische Methode ist writeTo(OutputStream out). Hinter ihr steckt ein out.write(buf, 0, count), das das interne Feld buf – das wir nicht sehen können – schreibt.

12.6.2 Bytes in den Strom schreiben mit ByteArrayInputStream 

ByteArrayInputStream ist InputStream, der aus Byte-Feldern ließt. Die Quelle der Daten wird im Konstruktor übergeben und dann intern nicht kopiert.

class java.io.ByteArrayInputStream
extends InputStream

ByteArrayInputStream( byte[] buf ) Erzeugt ein neues InputStream-Objekt, welches alle Daten aus dem Bytefeld buf liest.

ByteArrayInputStream( byte[] buf, int offset, int length ) Erzeugt ein ByteArrayInputStream, welches aus einem Teil des Feldes Daten entnimmt.

12.6.3 Ströme zusammensetzen mit SequenceInputStream 

Ein SequenceInputStream-Filter hängt mehrere Eingabeströme zu einem großen Eingabestrom zusammen. Nützlich ist dies, wenn wir aus Strömen lesen wollen und es uns egal ist, was für ein Strom es ist, wo er startet und wo er aufhört.

Ein SequenceInputStream lässt sich erzeugen, indem im Konstruktor zwei InputStream-Objekte mitgegeben werden. Soll aus zwei Dateien ein zusammengesetzter Datenstrom gebildet werden, nutzen wir folgende Programmzeilen:

InputStream s1 = new FileInputStream( "teil1.txt" );
InputStream s2 = new FileInputStream( "teil2.txt" );
InputStream s  =   new SequenceInputStream( s1, s2 );  

Ein Aufruf irgendeiner read()-Methode liest nun erst Daten aus s1. Liefert s1 keine Daten mehr, kommen die Daten aus s2. Liegen keine Daten mehr an s2, aber wieder an s1, ist es zu spät. Natürlich hätten wir diese Funktionalität auch selbst programmieren können, doch wenn etwa eine Methode nur einen InputStream verlangt, ist diese Klasse sehr hilfreich.

Für drei Ströme kann eine Kette aus zwei SequenceInputStream-Objekten gebaut werden.

InputStream in = new SequenceInputStream( stream1,
  new SequenceInputStream(stream2, stream3) );

Sollen mehr als zwei Ströme miteinander verbunden werden, kann auch eine Enumeration im Konstruktor übergeben werden. Die Enumeration einer Datenstruktur gibt dann die zu kombinierenden Datenströme zurück. Wir haben eine Datenstruktur, die sich hier gut anbietet: Vector. Wir packen alle Eingabeströme in einen Vector und nutzen dann die elements()-Methode für die Aufzählung.

Vector v = new Vector();
v.addElement( stream1 );
v.addElement( stream2 );
v.addElement( stream3 );
InputStream seq = new SequenceInputStream( v.elements() );

class java.io.  SequenceInputStream  
extends InputStream

SequenceInputStream( InputStream s1, InputStream s2 ) Erzeugt einen SequenceInputStream aus zwei einzelnen InputStream-Objekten. Zuerst werden die Daten aus s1 gelesen und dann aus s2.

SequenceInputStream( Enumeration e ) Die Eingabeströme für den SequenceInputStream werden aus der Enumeration mit next Element() geholt. Ist ein Strom ausgesaugt, wird die close()-Methode aufgerufen und der nächste vorhandene Strom geöffnet.

int available() throws IOException Liefert die Anzahl der Zeichen, die gelesen werden können. Die Daten betreffen immer den aktuellen Strom.

int read() throws IOException Liefert das Zeichen oder –1, wenn das Ende aller Datenströme erreicht ist.

int read( byte b[], int off, int len ) throws IOException Liest Zeichen in ein Feld und gibt die Anzahl tatsächlich gelesener Zeichen oder –1 zurück.

void close() throws IOException Schließt alle Ströme, die vom SequenceInputStream-Objekt eingebunden sind.

Beispiel

Das nachfolgende Programm zeigt, wie ein StringBufferInputStream mit einem Datenstrom zusammengelegt wird. Es werden anschließend Zeilennummern und Zeileninhalt ausgeben, wobei sehr schön deutlich wird, dass erst der String und dann die Datei ausgelesen wird. Die Datei muss sich im Pfad befinden, da sie sonst nicht gefunden werden kann.

Listing 12.13   SequenceInputStreamDemo.java

import java.io.*;

public class SequenceInputStreamDemo
{
  public static void main( String args[] )
  {
    String s = "Gezeitenrechnung\nfür\nSchlickrutscher\n";

    StringBufferInputStream sbis = new StringBufferInputStream( s );
    InputStream fis =
      SequenceInputStreamDemo.class.getResourceAsStream( "cat.java" );

    SequenceInputStream sis = new SequenceInputStream( sbis, fis );
    LineNumberInputStream lsis = new LineNumberInputStream( sis );

    System.out.print( "0: " );

    try
    {
      for ( int c; (c = lsis.read()) != –1; )
        System.out.print( (c == ’\n’) ?
                          ("\n" + lsis.getLineNumber() + ": ") : ""+(char)c );
    }
    catch ( IOException e ) { System.out.println( e ); }

    System.out.println();
  }
}

Leider verwendet das Programm zwei veraltete Klassen: StringBufferInputStream und LineNumberInputStream. Wir sind angehalten, für beide Ströme Reader-Klassen zu nutzen. Doch da es nur für Streams, aber nicht für Reader, einen Sequence-Strom gibt (eine Klasse SequenceReader haben die Entwickler wohl in ihrer Aufregung vergessen), haben die beiden veralteten Klassen zur Demonstration ihre Berechtigung. Die ersten Zeilen der Ausgabe sind:

0: Gezeitenrechnung
1: für
2: Schlickrutscher
3: import java.io.*;
4:
5: class cat
6: {
7:   public static void main( String args[] )
8:   {
9:     for ( int i=0; i < args.length; i++ )
10:     {
...

¹   Mehr zu Grafikformaten unter http://www.oreilly.com/centers/gff/gff-faq/gff-faq3.htm.