Byte-Ströme dienen zur Speicherung binärer Daten
Byte-Strom-Eingabe wird von der abstrakten Klasse InputStream realisiert:
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:
Daten aus einem Byte-Array im Speicher lesen.
Teil des Object Serialization
APIs (neu in Java1.1) zur Ausgabe von Objekten
(siehe Seite ).
implementiert die Eingabe-Seite einer Pipe.
Lesen aus StringBuffer-Objekten (veraltet, daher: deprecated-Meldung).
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; } }
Filterströme werden mit anderen Eingabeströmen verbunden, um die eingelesenen Daten weiterzubearbeiten.
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.:
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))); } }
Byte-Strom-Ausgabe wird von der abstrakten Klasse OutputStream realisiert:
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); } } }
Die Klasse PrintStream liefert Methoden zur Ausgabe der textuellen Darstellung der Java-Grundtypen.
Da sie eher zur Zeichenausgabe (siehe Seite ) gehört,
wird die Klasse nicht mehr benutzt. Statt dessen kommt
die Klasse PrintWriter (siehe Seite
) zum Einsatz.
Einzige Bedeutung:
Die beiden Standard-Ausgabedateien System.out und System.err sind vom Typ PrintStream.