next up previous contents index
Next: Zeichen-Ströme Up: Ein-/Ausgabe Previous: Ein-/Ausgabe

Byte-Ströme

 

Byte-Ströme dienen zur Speicherung binärer Daten

Binäre Eingabe-Ströme

Byte-Strom-Eingabe wird von der abstrakten Klasse InputStream realisiert:

tex2html_wrap2280

Beispiel: Zähle die Zeichen in einer Datei

import java.io.*;

class CountChars
{ public static void main(String argv[])
  throws IOException
  { InputStream in;
    if (argv.length != 0)
      in = new FileInputStream(argv[0]);
    else in = System.in;
    int ch;
    int total=0;
    while ((ch = in.read()) != -1)
      total++;
    System.out.println("Number of chars: "
                       + total);
  }
}

Neben dem oben verwendeten FileInputStream existieren:

Folgen von Eingabeströmen

 

SequenceInputStream wird verwendet um ein Folge von Eingabeströmen zu verarbeiten:

import java.io.*;
class Concatenate 
{ public static void main(String[] a) 
  { ListOfFiles mylist = new ListOfFiles(a);
    try 
    { SequenceInputStream s = 
            new SequenceInputStream(mylist);
      int c;
      while ((c = s.read()) != -1) 
        System.out.write(c);
      
      s.close();
    } 
    catch (IOException e) 
    { System.err.println
                ("Concatenate: " + e);
    }
  }
}

Hier ist die notwendige Enumeration:

import java.util.*;
import java.io.*;

class ListOfFiles implements Enumeration 
{ String[] listOfFiles;
  int current = 0;
  ListOfFiles(String[] listOfFiles) 
  { this.listOfFiles = listOfFiles;
  }
  public boolean hasMoreElements() 
  { return current < listOfFiles.length;
  }
  public Object nextElement() 
  { InputStream is = null;
    if (!hasMoreElements())
      throw new NoSuchElementException();
    else 
    { try 
      { String next = listOfFiles[current++];
        is = new FileInputStream(next);
      } 
      catch (FileNotFoundException e) {}
    }
    return is;
  }
}

Gefilterte Binär-Eingabe

 

Filterströme werden mit anderen Eingabeströmen verbunden, um die eingelesenen Daten weiterzubearbeiten.

tex2html_wrap2282

Neben der Verwendung dieser Filter-Strom-Klassen aus der Bibliothek besteht die Möglichkeit, eigene Filterklassen zu schreiben.

Benutzung am Beispiel von DataInputStream:

import java.io.*;
class CountLines
{
  public static void main(String a[])
  throws IOException
  { InputStream in;
    if (a.length != 0)
      in = new FileInputStream(a[0]);
    else in = System.in;

    DataInputStream dis = 
        new DataInputStream(in);
    String inp;
    int total = 0;
    while (( inp = dis.readLine()) != null)
      total++;
    System.out.println("Number of lines: "
                       + total);
  }
}

DataInputStream liefert Einlesemethoden für alle gängigen Datentypen, u.a.:

tex2html_wrap2164

public final byte readByte();
public final char readChar();
public final double readDouble();
public final float readFloat();
public final int readInt();
public final String readLine();
public final long readLong();
public final short readShort();

Gepufferte Binär-Eingabe

Die Klasse BufferedInputStream steigert die Effizienz der Eingabe, indem größere Datenmenge in einem internen Puffer zwischengespeichert werden.

public class InFile extends DataInputStream 
{ public InFile(String filename)
  throws FileNotFoundException 
  { super(
      new BufferedInputStream(
        new FileInputStream(filename)));
  }
}

Binäre Ausgabe-Ströme

Byte-Strom-Ausgabe wird von der abstrakten Klasse OutputStream realisiert:

tex2html_wrap2399

import java.io.*;
class BinIO 
{ public static void main(String[] args) 
  { try 
    {  FileInputStream fis = 
        new FileInputStream("try.txt");
      FileOutputStream fos = 
        new FileOutputStream("try_cp.txt");
      int c;
      while ((c = fis.read()) != -1) 
      { fos.write(c);
      }
      fis.close(); 
      fos.close();
    } 
    catch (IOException e) 
    { System.err.println("BinIO: " + e);
    }
  }
}

Ausgabe textueller Darstellung der Grundtypen

 

Die Klasse PrintStream liefert Methoden zur Ausgabe der textuellen Darstellung der Java-Grundtypen.

Da sie eher zur Zeichenausgabe (siehe Seite gif) gehört, wird die Klasse nicht mehr benutzt. Statt dessen kommt die Klasse PrintWriter (siehe Seite gif) zum Einsatz.

Einzige Bedeutung:

Die beiden Standard-Ausgabedateien System.out und System.err sind vom Typ PrintStream.


next up previous contents index
Next: Zeichen-Ströme Up: Ein-/Ausgabe Previous: Ein-/Ausgabe

Peter Pfahler, 1997