Vorlesung 11. Sitzung Grundlegende Programmiertechniken

Transkript

1 Vorlesung 11. Sitzung Grundlegende Programmiertechniken Wintersemester 2007/2008 Dozent Nino Simunic M.A. Computerlinguistik, Campus DU

2 Grundlegende Programmiertechniken, WS 2007/2008 Datenströme

3 Externe Informationen lesen/schreiben Häufige Software-Operationen: (Ein-)Lesen von Daten/Informationen aus einer externen Quelle in die Java-Umgebung einlesen Schreiben von Informationen aus dem Programm in ein externes Ziel. In allen Fällen sind E/A Datenströme die Basis. -3-

4 Wichtige Merkmale der Ströme Ein Strom kann die verschiedensten Typen von Quellen und Zielen repräsentieren. Dateien, Geräte, andere Programme, Arrays im Speicher, Ströme unterstützen verschiedene Typen von Daten Bytes, primitive Datentypen, lokalisierte Zeichen, Objekte, Einige Strom-Typen befördern Daten ausschließlich, andere dagegen manipulieren sie auf sinnvolle Weise. -4-

5 Grundlage aller E/A Operationen: Lesen In allen Fällen gilt beim Lesen von Daten: Ein Strom ist eine Daten-Sequenz. Ein Programm verwendet Input-Streams, um Daten sequenziell/stückweise zu lesen. -5-

6 Grundlage aller E/A Operationen: Schreiben In allen Fällen gilt beim Schreiben von Daten: Ein Strom ist eine Daten-Sequenz. Ein Programm verwendet Output-Streams, um Daten sequenziell/stückweise zu lesen. -6-

7 Einleitung : E/A Ströme in Java (3) Algorithmus der sequentiellen Datenverarbeitung sowohl beim Lesen als auch beim Schreiben: Lesen Strom öffnen Mehr Informationen? Lese Informationen Strom schließen Schreiben Strom öffnen Mehr Informationen? Schreibe Informationen Strom schließen Mehr Informationen? zu zu verstehen als Schleife mit Bedingung Solange Informationen vorhanden -7-

8 Paket java.io java.io enthält Strom-Klassen für die Umsetzung von E/A Aktionen Strom-Klassen sind grundlegend auf zwei Klassenhierarchien verteilt: Zeichen-Ströme:»Textuelle«Informationen Byte-Ströme: Informationen als Rohdaten -8-

9 Rohdaten-/Byte-Ströme Byte-Strom Klassen sind Ableitungen von InputStream und OutputStream. Typische Anwendungen: Lesen und Schreiben binärer Daten: Bilder, Sounds, Objekte, -9-

10 Byte-Ströme: Einige Subklassen von InputStream und OutputStream Byte-Ströme: Öffnen/Lesen abstract Byte-Ströme: Öffnen/Schreiben InputStream OutputStream FilterInputStream FileInputStream FilterOutputStream FileOutputStream BufferedInputStream InflaterInputStream BufferedOutputStream GZIPInputStream ZipInputStream Wahlfreie DV (vs. sequentielle DV) Printstream

11 Details der Byte-I/O Superklassen (1) InputStream InputStream FileInputStream definiert u.a. Methoden für das Lesen von Bytes und Byte-Arrays: int read() InflaterInputStream int read(byte cbuf[]) int read(byte cbuf[], int offset, GZIPInputStream int length) ZipInputStream FilterInputStream BufferedInputStream

12 Details der Byte-I/O Superklassen (2) OutputStream OutputStream definiert ähnliche Methoden FilterOutputStream FileOutputStream zum Schreiben von Bytes: int write(int c) int write(byte cbuf[]) BufferedOutputStream int write(byte Printstream cbuf[], int int write(byte cbuf[], int offset, int length)

13 Öffnen/Schließen von Streams Alle Ströme werden bei ihrer Erzeugung automatisch geöffnet Gilt für InputStream's, OutputStream's, aber auch die noch folgenden Reader's, und Writer's Ströme sollten stets nach erfolgter Verwendung via close()-methode geschlossen werden. Der garbage collector schließt Ströme implizit, wenn ein Strom-Objekt nicht mehr referenziert wird

14 Verwendung von Byte-Strömen Demonstration von Byte-Strömen anhand von E/A Byte-Strömen fürs Lesen/Schreiben von Dateien. Andere Typen von Byte-Strömen werden fast analog hierzu verwendet: Hauptunterschied ist die Art Ihrer Erzeugung. Beispiel-Projekt: Kopiere Informationen aus einer Datei in eine andere Verwendete Strom-Klassen im Projekt: FileInputStream, FileOutputStream

15 CopyBytes.java import java.io.*; public class CopyBytes { FileIS, FileOS Konstruktoren: -Dateiname als Zeichenkette -Ein File-Objekt (Hausaufgabe) -Ein FileDescriptor Objekt public static void main(string[] args) throws IOException { FileInputStream in = null; FileOutputStream out = null; try { in = new FileInputStream("test.txt"); out = new FileOutputStream("test_copy.txt"); int c; while ((c = in.read())!= -1) { out.write(c); finally { if (in!= null) { in.close(); if (out!= null) { out.close();

16 Ströme und Ausnahmen In vielen Fällen können Ströme Ausnahmen auslösen Datei nicht gefunden/korrupt/schreibgeschützt, Netzwerkverbindung down, In ebenso vielen Fällen verpflichten die I/O-Klassen den Programmierer zur Ausnahmebehandlung Die Ausnahmen sind ebenfalls in java.io zu finden. Welche Ausnahme erzeugt werden kann, steht in der Java-API, bzw. sagt Ihnen die IDE bzw. der Compiler

17 Wann man Byte Ströme nicht verwenden sollten CopyBytes funktioniert zwar (Text), stellt jedoch low-level E/A dar, welches i.d.r. vermieden werden sollte. test.txt enthält Zeichen-Daten, also komplexe Daten Nebenbei: Byte Ströme sind auf ISO-Latin-1 8-bit Bytes begrenzt. Kann zu Problemen führen. Idealfall ist die Nutzung entsprechender Ströme für komplexe Daten. Hier also Zeichen-Ströme! Noch einmal: Vermeiden Sie low-level E/A. Warum dann überhaupt ansehen? Alle anderen Strom- Typen haben Byte-Ströme als Grundlage! ;-)

18 Zeichen-Ströme (engl. character streams) Im Allgemeinen ist E/A mit Zeichenströmen nicht sonderlich komplizierter als mit Byte-Strömen. Wichtiges Konzepte hier: Zeichenkodierungen. Java Plattform speichert Zeichen auf Unicode Basis Internes Format wird automatisch übersetzt in/von der lokalen Zeichencodierung Man kann den Automatismus nutzen, oder aber auch bequem eigene Zeichenkodierungen beim Erzeugen der Ströme einfach angeben, falls erforderlich!

19 Zeichen-Ströme Reader und Writer sind abstrakte Superklassen aller Zeichen-Ströme Ihre Subklassen implementieren spezifische Ströme für Datei E/A (analog zu den Byte-Strömen) Ströme, die direkt in data sinks (Datensenken) lesen/schreiben (analog zum letzten Beispiel) Filter-Ströme, die nicht direkt mit der Datensenke verbunden sind und die Daten sinnvoll vor dem Einlesen/Schreiben prozessiert

20 Zeichen-Ströme: Einige Subklassen von Reader und Writer Zeichen-Ströme:Öffnen/ Lesen Lesen abstract Zeichen-Ströme: Öffnen/Schreiben Reader Writer BufferedReader InputStreamReader FilterWriter BufferedWriter LineNumberReader FileReader OutputStreamWriter FileWriter

21 Details der Zeichen-I/O Superklassen (1) Reader und InputStream definieren ähnliche APIs, jedoch für unterschiedliche Datentypen: int read() int read(char cbuf[]) int read(char cbuf[], int offset, int length) Analog zu InputStream: Methoden zum Flush'en, Überspringen, Markieren, Zurücksetzen

22 abstract void close() Closes the stream and releases any system resources associated with it. void mark(int readaheadlimit) Marks the present position in the stream. boolean marksupported() Tells whether this stream supports the mark() operation. boolean ready() Tells whether this stream is ready to be read. void reset() Resets the stream. long skip(long n) Skips characters

23 Details der Zeichen-I/O Superklassen (2) Writer und OutputStream ähneln sich ebenfalls in den definierten Methoden write(char[] cbuf) Writes an array of characters. abstract void write(char[] cbuf, int off, int len) Writes a portion of an array of characters. void write(int c) Writes a single character. void write(string str) Writes a string. void write(string str, int off, int len) Writes a portion of a string. Wie gehabt: Öffnen der Ströme automatisch bei Erzeugung des jeweiligen Strom-Objekts

24 Anwendungsdemonstration am Beispiel Datei-E/A Analog zu Byte-Strömen: Klassen vorhanden, welche Datei-E/A auf Zeichenstrom-Ebene realisieren Beispiel-projekt: CopyCharacters Gleiche Funktionalität wie CopyBytes. Wichtigster Unterschied: Anstelle von FileInputStream und FileOutputStream für E/A: FileReader, FileWriter

25 CopyCharacters.java import java.io.*; public class CopyCharacters { public static void main(string[] args) throws IOException { FileReader inputstream = null; FileWriter outputstream = null; try { inputstream = new FileReader("test.txt"); outputstream = new FileWriter("test_copy2.txt"); int c; while ((c = inputstream.read())!= -1) { outputstream.write(c); finally { if (inputstream!= null) { inputstream.close(); if (outputstream!= null) { outputstream.close();

26 Zeichen-Ströme, die Byte-Ströme verwenden Zeichenströme sind oft "Wrapper" für Byte-Ströme Der Zeichenstrom verwendet den Bytestrom für physikalisches I/O Der Zeichenstrom übernimmt die Aufgabe der Übersetzung zwischen Zeichen und Bytes FileReader z.b. verwendet FileInputStream FileWriter verwendet FileOutputStream Insgesamt zwei»general-purpose«byte-zu- Zeichen»Brücken«-Ströme InputStream / Reader OutputStream / Write

27 Zeilen-basiertes I/O Zeichen E/A wird i.d.r. in größeren Einheiten (als nur einzelne Zeichen) realisiert. Eine typische Einheit: Zeile (eines Texts) Eine Zeichenkette, welcher mit einem Zeilenumbruch endet. Beispiel: CopyLines Verwendet BufferedReader.readLine und PrintWriter.println für zeilenweises E/A

28 CopyLines.java import java.io.*; public class CopyLines { public static void main(string[] args) throws IOException { BufferedReader inputstream = null; PrintWriter outputstream = null; try { inputstream = new BufferedReader(new FileReader("test.txt")); outputstream = new PrintWriter(new FileWriter("text_out.txt")); String l; while ((l = inputstream.readline())!= null) { outputstream.println(l); finally { if (inputstream!= null) { inputstream.close(); if (outputstream!= null) { outputstream.close();

29 Filterströme: Puffer-Ströme (engl. buffered streams) Buffered I/O (gepuffertes E/A) Means that each read or write request is handled directly by the underlying OS. Can make a program much less efficient, since each such request often triggers disk access, network activity, or some other operation that is relatively expensive. Um diesen Overhead zu vermeiden: Buffered I/O streams Buffered input streams read data from a memory area known as a buffer; the native input API is called only when the buffer is empty. Similarly, buffered output streams write data to a buffer, and the native output API is called only when the buffer is full

30 Buffered Streams (2) Ein Programm kann einen ungepufferten Strom in einen gepufferten Strom konvertieren Ungepufferter Strom wird vom Puffer-Strom»verpackt«, bzw. diesem als Objekt übergeben Beispiel: CopyCharacters mit gepuffertem Strom Einzige Änderung: Dem ungepuffertem wird ein gepufferter Strom zwischengeschaltet. Buffered Stream BufferedReader new BufferedReader( ) Unbuffered Stream FileReader new Filereader( )

31 CopyCharacters2.java import java.io.*; public class CopyCharacters2 { public static void main(string[] args) throws IOException { BufferedReader FileReader inputstream inputstream = null; = null; FileWriter BufferedWriter outputstream outputstream = null; = null; try { inputstream = new = new BufferedReader(new FileReader("test.txt"); FileReader("test.txt")); outputstream = new = new BufferedWriter(new FileWriter("test_copy2.txt"); FileWriter("test_copy.txt")); int c; while ((c = inputstream.read())!= -1) { Vier outputstream.write(c); gepufferte Stromklassen zum Wrappen ungepufferter Ströme: finally { BufferedInputStream, if (inputstream!= null) { BufferedOutputStream erstellten inputstream.close(); gepufferte Byte-Ströme if (outputstream!= null) { BufferedReader und outputstream.close(); BufferedWriter erzeugen gepufferte Zeichenströme

32 Flush'en von gepufferten Strömen It often makes sense to write out a buffer at critical points, without waiting for it to fill. This is known as flushing the buffer. Some buffered output classes support autoflush, specified by an optional constructor argument. When autoflush is enabled, certain key events cause the buffer to be flushed. For example, an autoflush PrintWriter object flushes the buffer on every invocation of println or format. To flush a stream manually, invoke its flush method. The flush method is valid on any output stream, but has no effect unless the stream is buffered

33 E/A auf der Kommandozeile Programm verwenden häufig die Kommandozeile, um mit dem Benutzer zu interagieren Eine Möglichkeit der Umsetzung: Verwenden von Standard-Strömen

34 Standard Streams (1) Standard Streams sind Features von vielen Betriebssystem. Standardmäßig lesen Sie Input der Tastatur und schreiben auf den Bildschirm Die Java Plattform unterstützt drei Standard-Ströme: Standard Input: Zugriff via System.in Standard Output: Zugriff via System.out Standard Error: Zugriff via System.err Standard Output, Standard Error sind Ausgabe-Ströme. Ihre jeweilige Formatierung erlaubt jedoch, Fehler von regulären Ausgaben schnell zu unterscheiden. Objekte dieser Ströme werden automatisch definiert und müssen nicht geöffnet werden

35 Standard Streams (2): Vorsicht Aus historischen Gründen: Die Standardströme sind keine Zeichen-Ströme, sondern Byte-Ströme System.out und System.err werden als PrintStream Objekte definiert. Obwohl sie Byte-Ströme sind, verwendet PrintStream einen eigenen internen Zeichen-Strom, um viele der Features von Zeichen-Ströme zu emulieren. Im Gegensatz dazu ist System.in ein Byte-Strom with ohne Zeichenstrom-Funktionalität. Um den Standard Input als Zeichenstrom zu nutzen, muss System.in gewrappt werden: System.in in InputStreamReader: InputStreamReader stdin = new InputStreamReader(System.in);

36 Hausaufgabe Kapitel»Scanning and Formatting«lesen, Quelltexte implementieren, ausprobieren, erweitern. Download ab morgen auf unserer Seite Evtl. Zusatzliteratur aus Head First Java Übungsaufgaben nächste Woche setzen das Lesen des Kapitels voraus. Fragen? Aufschreiben! Wie immer: Auch Folien nachbereiten, Quelltexte ausprobieren (auch die der Hausaufgaben-Kapitel), erweitern, etc. Next: Collections, Generezität, Ereignisbasierte Programmierung, GUI-Entwicklung Warnung: Evtl. müssen wir 2h in den Ferien machen

37 Referenzen Sharon Zakhour, Scott Hommel, Jacob Royal, Isaac Rabinovitch, Tom Risser, Mark Hoeber The Java Tutorial Fourth Edition: A Short Course on the Basics. Addison Wesley Professional. Java (1.6) API Dokumentation