AK-Automatisierungs und Kommunikationstechnik TI Technische Informatik. NWT Netzwerktechnik

Transkript

1 Aufgaben: Ein Ausgabe Ein Rechner verwaltet nicht nur Daten, die während der Laufzeit des Programms erzeugt werden. Die meisten Programme greifen auf ältere Datenbestände zurück oder erzeugen für einen späteren Gebrauch Daten. Ein Javaprogramm muss also Daten in eine Datei schreiben oder aus einer Datei Daten lösen können. Wieder benutzen wir die gleiche Technik: Beim Schreiben in eine Datei speist das Javaprogramm die zu sichernden Daten in ein Pipeline, die das System wieder ausliest und in eine Datei z.b. auf eine Festplatte speichert. Schauen wir uns das in einem Beispielprogramm an.: /* * NetzwerkProgrammierung - Streams * Einlesen * Munz */ import java.io.*; public class SchreibeInDatei { public static void main (String[] args) throws IOException{ String text = "Dieser Text wird in einer Datei gespeichert!"; String dateiname = "D:/temp/Test.txt"; FileOutputStream schreibestrom = new FileOutputStream(dateiName); for (int i=0; i < text.length(); i++){ schreibestrom.write((byte)text.charat(i)); schreibestrom.close(); System.out.println("Datei ist geschrieben!"); Nachdem das Programm abgearbeitet ist, man erkennt dies daran, dass auf dem Bildschirm die Ausgabe "Datei ist geschrieben!" erscheint, gibt es in dem Verzeichnis, in dem das Programm gespeichert ist eine Datei mit dem Namen Test.txt. Öffnen wir diese Datei mit dem Standard Editor von Windows, so sehen wir den gespeicherten Text. Ist das tatsächlich so, dass der Text in der Datei steht? Wir analysieren unser Programm und werden dabei versuchen diese Frage zu beantworten. Die Pipeline zwischen dem Javaprogramm und dem System ist sehr einfach gebaut. Sie verlangt dass die Daten als bytes eingespeist werden. Das Rechnersystem liest aus der Pipeline die Daten auch wieder in 1 Byte großen Blöcken und speichert diesen Code auf die Platte, wobei der Dateiname das System von dem Javaprogramm mitgeteilt bekommen muss. In FileOutputStream schreibestrom = new FileOutputStream(dateiName); wird ein Ausgabestrom Objekt schreibestrom der Klasse FileInputStream erzeugt. Als Parameter wird dem Konstruktor der Name der Datei als String übergeben. Der Dateiname ist dabei vollkommen willkürlich. An Stelle von Test.txt hätte man genauso 1

2 gut mein.bla oder Test.jpg wählen können. Warum wir es nicht tun, werden wir später sehen. Nachdem die Pipeline angelegt ist, müssen wir nur noch die Daten in die Pipeline einspeisen. Dazu benutzen wird die Methode write(byte paket) der Klasse FileOutputStream. schreibestrom.write((byte)text.charat(i)); Es wird aus dem Text, den wir speichern wollen ein Zeichen (char) gelesen (text.charat(i)), explizit zu einem byte gecastet (casting = Typumwandlung) und danach in die Pipeline geschrieben. Ist der ganze in der Pipeline, wir benutzen dazu eine Schleife, schließen wir die Pipeline mit der close() Methode, das Rechnersystem übernimmt die Kontrolle liest aus der Pipeline die Daten (im Prinzip nichts anderes als eine Reihung von Nullen und Einsen) schreibt sie in die Datei auf der Festplatte und gibt die Kontrolle an das Javaprogramm zurück. Klicken wir von Windows aus auf die Datei Test.txt, so wird die Datei vom Standard Editor geöffnet, denn bei einer 'txt' Endung 'geht Windows geht davon aus', dass es sich um eine einfache Textdatei handelt. Wie geschieht es, dass der Editor den Inhalt der Datei 'Test.txt' auch als Text auf den Bildschirm schreibt? Nun das ist jetzt einfach: Der Editor, der ja davon ausgeht, dass es sich bei der Datei um eine Textdatei handelt, liest aus der Datei 1 Byte große Blöcke, interpretiert ihren Inhalt als ASCII Zeichen und schreibt das zum Zahlenwert gehörige Zeichen auf den Bildschirm. Der Windows Editor benutzt zum Auslesen der Datei ebenfalls einen Eingabestrom. Und woher weiß der Editor wann, das Ende des Datenstroms gekommen ist und deshalb nicht über das Ende hinaus liest? Es gibt in der Datei tatsächlich eine Endemarkierung, die beim Schreiben der Datei vom System hinzugefügt wurde. Wir wollen diesen Sachverhalt genauer untersuchen indem wir ein Javaprogramm schreiben, das eine Datei ausliest. /* * NetzwerkProgrammierung - Streams * Auslesen * Munz */ import java.io.*; public class LeseAusDatei { public static void main (String[] args) throws IOException{ byte zeichen; char buchstabe; String text = ""; String dateiname = "D:/temp/Test.txt"; FileInputStream lesestrom = new FileInputStream(dateiName); do{ zeichen = (byte)lesestrom.read(); System.out.print(zeichen+" "); text += (char)zeichen; while (zeichen!=-1); lesestrom.close(); System.out.println(); System.out.println(text); 2

3 Statt einer Ausgabe Pipeline benutzen wir eine EingabePipeline, die in einem FileInputStream Objekt nämlich lesestrom verwaltet wird. Mit der read() Methode werden aus der Ausgabe Pipeline 1 Byte große Pakete gelesen. die read() als int Werte an das aufrufende Javaprogramm liefert, wo sie nach einem expliziten Cast in der byte Variablen zeichen gespeichert werden. Zur Kontrolle werden diese Zeichen ausgegeben. Ein weiterer expliziten Typenumwandlung castet den Inhalt von zeichen zu in einem char. Schließlich wird die ganze Zeichenkette aufgebaut und schließlich ausgegeben Dieser Text wird in einer Datei gespeichert!? Wir erkennen also, was tatsächlich in der Textdatei stand und dass erst die Interpretation einen Text daraus macht. Und noch ein weiteres zeigt die Ausgabe: Das letzte Zeichen in der Datei ist ' 1' als Byte Zeichen! Es übernimmt die Rolle von 'Der letzte macht die Tür zu'. Jetzt verstehen wir auch die Abbruchbedingung in unserer do while Schleife. Interpretieren wir dieses Schlusszeichen als char Zeichen, dann wird daraus ein '?' Zeichen. Der Windows Editor gibt dieses Schlusszeichen nicht aus. Ein etwas modifiziertes Javaprogramm würde das gleiche leisten. ASCII-Tabelle!! bei der Darstellung wird allerdings auf die führenden 0 en verzichtet. Genauer müsste es heißen:

4 In der Pipeline sind also folgende Daten: Die farbliche Hervorhebung hat nur den Sinn, dem Leser die 'alten' Blöcke noch erkennen zu lassen. Tatsächlich werden die zuerst eingelesenen Daten wieder aus dem Strom herausgeholt. Geschieht dies so, dass immer 8 Ziffern (8 bit = 1 Byte) herausgelesen werden, ist dies schon ein Teil der Interpretation, die dadurch vollendet wird, dass das herausgeholte Packet Data Segment Paket Frame es laufen Pakete übers Netz als ASCII Code 'verstanden'. Tatsächlich hätte beim Einspeisen in den Datenstrom die Zahlenfolge auf ganz andere Art entstanden sein könne. Beim Auslesen würde auch in diesem Fall die Pakete als ASCII Code interpretiert. So entstehen dann eine wirre Folge von Zeichen. Wir speichern folgende Grafik auf der Festplatte unter D:\temp 4

5 Und schreiben folgendes Programm. Werte, die keinen ASCII Code haben werden als Leerzeichen dargestellt. Wir sehen. Unser Programm macht in sofern einen Unsinn, weil es die Datei nicht richtig interpretiert. Benutz man den Windows Editor um Theseus.bmp zu interpretieren, ergibt sich: 5

6 Wir erhöhen in einem zweiten Leseprogramm die Anzahl Schleifendurchgänge auf 20 und geben Sie wieder den Satz 'Java ist toll' ein. Beschreiben und erklären Sie warum das Programm so reagiert wie es reagiert. Besitzt der Eingabetext weniger als 20 Zeichen, etwa 13 bei der Eingabe unseres Standardtextes "Java ist toll", so 'erkennt die read() Methode, dass die Eingabe Pipeline leer ist, hält das Javaprogramm an und übergibt die Kontrolle dem Rechnersystem, das eine neue Eingabe erwartet. Erst wenn diese Eingabe abgeschlossen ist, liest read() erneut Daten aus der Pipeline. 6

7 In der Dezimaldarstellung sind es die Zeichen Im Binärcode eigentlich Die Bedeutung dieser Zeichen oder besser ihre Interpretation heißen CR = Carriage Return (Wagenrücklauf) und LF = Line Feed (Zeilenvorschub) und bedeuten damit nichts anderes, als das Drücken der Eingabetaste. Um einen Eingabestrom auszulesen ohne den Byte Code für das Drücken der Entertaste abzufragen, verwendet man die Methode available(). Sie liefert die Anzahl der Bytes, die im Eingabestrom sind. 7

8 Eine berechtigte Frage ist, wieviel, genauer wie viele 1 Byte Große Pakete passen in einen Strom. Eine Antwort gibt das nächste Programm : /* * NetzwerkProgrammierung - Streams * LiesPuffer * Wie groß ist die Pipe? * Munz */ import java.io.*; public class LiesPuffer { public static void main(string[] args) throws IOException { DataOutputStream ausgabe = new DataOutputStream(System.out); for (int j=1; j<=129; j++) { ausgabe.writebyte(65); 8

9 Das Programm zeigt keine Reaktion. Es wird 127 mal der Byte Wert 65 (ASCII Code für das Zeichen 'A') in den Ausgabestrom gespeist. Erhöht man den Zähler auf 129, so ist der Strom gefüllt, das System übernimmt die Kontrolle leert den Strom und gibt die die Werte aus, wobei einzelne Byte Pakete als ASCII Code interpretiert werden. Auf dem Bildschirm erscheint also 128 mal der der Buchstabe 'A'. Folgendes Beispiel auf der nächsten Seite liest einen Text von der Standardeingabe ein und speichert ihn in einer Datei, bis ein x eingegeben wird. Anschließend wird diese Datei ausgelesen und ihr Inhalt auf der Standardausgabe ausgegeben: 9

10 import java.io.*; public class FileDemo { final static String name = "FileDemo.dat"; public static void main(string args[]) { File textfile; // Textdatei FileReader in; // Dateieingabe-Stream FileWriter out; // Dateiausgabe-Stream // Standardeingabe in Reader umwandeln BufferedReader stdin; stdin = new BufferedReader( new InputStreamReader(System.in)); PrintWriter stdout=new PrintWriter(System.out,true); // Erzeugen eines Ausgabe-Streams, der mit der Datei // 'FileDemo.dat' verknüpft ist try { out = new FileWriter(name); int key = 0; // Einlesen von Text von der Standardeingabe // bis zur Eingabe eines x und // gleichzeitiges Abspeichern des Textes do { try { key = stdin.read(); out.write(key); catch(ioexception e) { e.printstacktrace(); while((char)key!= 'x'); out.close(); // Schließen der Datei // Erzeugen eines Eingabe-Streams, der mit // der Datei verknüpft ist textfile = new File(name); in = new FileReader(textFile); int size = (int)textfile.length(); // Dateilänge int read = 0; // Anzahl der gelesenen Zeichen char data[] = new char[size]; // Lesepuffer // Auslesen der Datei while (read < size) read =+ (byte)in.read(data, read, size-read); in.close(); // Ausgabe des Lesepuffers stdout.println(new String(data)); catch (IOException ex) { ex.printstacktrace(); Flushing Streams 10