Dateien,Streams

INE2
Dateien, Ströme
■ Einführung und Allgemeines zum Zugriff auf Dateien
■ Sequentieller Dateizugriff
■ Die wichtigsten Java IO-Klassen
■ Lesen von Files und Schreiben in Files in Java
■ Konsolen-IO und die System-Klasse
■ Lesen von anderen Medien
■ Persistente Objekte
Einführung
School of Engineering
© G. Burkert, K. Rege, ZHAW
2 von 58
Datei/File
■ Problem
■
■
Daten im Arbeitsspeicher (RAM) gehen beim Ausschalten des Computers verloren
Wir brauchen eine Möglichkeit, um diese Daten permanent zu speichern
■ -> zusammengehörige Daten werden zu Dateien (Eng: File = Ablage) zusammengefasst und
als eine Einheit behandelt
■ Datei/File
■
■
■
■
Eine Folge von Bytes (Stream of Bytes)
Zusammengehörige Daten werden zu Dateien zusammengefasst um diese Daten effizient auf
permanente Speichermedien ablegen und wieder auslesen zu können
Beliebige Arten von Daten können gespeichert werden: Text, Zahlen, Bilder, Video, Sound,
Programme, Objekte...
Die Interpretation der Byte-Folge in einer Datei ist Sache des entsprechenden Programms
School of Engineering
© G. Burkert, K. Rege, ZHAW
3 von 58
Files in Java
School of Engineering
© G. Burkert, K. Rege, ZHAW
4 von 58
Die Klasse File
■ Methoden, um Dateien und Verzeichnisse als Ganzes zu bearbeiten
(Verzeichnisse sind auch Dateien)
■ Instanzierung/Existenzprüfung:
■ File myFile = new File(String absFileName);
■
■
erzeugt ein File-Object, nicht das File selbst
absFileName: Filename samt absolutem Pfad
■ (\ durch \\ im String ersetzen!)
■ Methode zur Existenzprüfung
■
boolean exists() : prüft ob vorhanden
■ Methoden zur Prüfung von Eigenschaften
■
boolean isFile() : Testest, ob Datei
■
boolean isDirectory() : Testest, ob Verzeichnis
■
boolean canRead () : Testet, ob Lesen erlaubt
■
boolean canWrite() : Testet, ob Schreiben erlaubt
■
String getName(): gibt Dateinamen zurück
■
String getPath() : gibt relativen Pfad zurück
■
String getAbsolutePath() :gibt absoluten Pfad zurück
School of Engineering
© G. Burkert, K. Rege, ZHAW
5 von 58
Die Klasse File
■ Methoden zur Verzeichnisdurchsuche
■
String[] list() : retourniert Liste aller Dateien
■ Methode zur Dateiumbenennung/Löschung
■
■
boolean renameTo(File dest) : benennt File um
boolean delete() : löscht Datei; true -> war vorhanden
■ Beispiel: Auflisten von Windows Verzeichnis
File dir = new File("C:\\windows");
String[] dirNames = dir.list();
for (int i = 0; i < dirNames.length; i++) {
String fn = dirNames[i];
File f = new File(fn);
if (f.isDirectory()) fn = fn + " dir";
System.out.println(fn);
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
6 von 58
Dateizugriffsströme
School of Engineering
© G. Burkert, K. Rege, ZHAW
7 von 58
Dateizugriff: stream oder random access->
Zwei grundsätzliche Möglichkeiten, um auf Dateien zuzugreifen:
■ Wahlfreier Zugriff, wie z.B. bei Arbeitsspeicher, HD, DVD...
■
■
■
Dieser Zugriff wird auch als direktadressierter Zugriff (random access) bezeichnet
Zugriff erfolgt wie auf den internen Speicher über eine Adresse/Position
Random Access auf Dateien wird nur in speziellen Fällen benötigt, zB bei Datenbanken
■ Sequentieller Zugriff:
■
■
■
■
Die Daten werden wie bei einem Tonband von vorne beginnend nacheinander eingelesen
Dieser Zugriff wird auch als Strom-Zugriff (stream access) bezeichnet
Dies ist die häufigste Art, auf Dateien zuzugreifen
Streams findet man z.B. auch bei der Datenübertragung über ein Netzwerk
■ Wir beschränken uns hier auf den Sequentiellen Zugriff
School of Engineering
© G. Burkert, K. Rege, ZHAW
8 von 58
Direkter sequentieller Dateizugriff
■ Grundlegende Operationen
■
Lesen eines Files: File öffnen, Daten nacheinander lesen und intern abspeichern,
File schliessen:
■
Schreiben eines Files: File öffnen, Daten nacheinander schreiben, File schliessen:
■ Direkter sequentieller Zugriff:
■
■
■
Daten werden Byte für Byte gelesen/geschrieben -> Datenstrom (Stream)
Vorteil: maximale Kontrolle des
Programmierers, denn Daten werden
unmittelbar auf/von Datei geschrieben/
gelesen
Nachteile: langsam, Applikation wird
jedesmal blockiert, bis das Byte gelesen/
geschrieben ist
-> ev. Zeit bis R/W Kopf auf richtigem Track
+ Zeit bis richtiger Sektor unter R/W Kopf
+ Zeit bis Daten gelesen und transferiert
School of Engineering
© G. Burkert, K. Rege, ZHAW
9 von 58
Gepufferter sequentieller Zugriff
■ Daten werden blockweise gelesen/
geschrieben, Zwischenspeicherung im
Arbeitsspeicher
■ Vorteile:
■
■
Die Applikation ist weniger blockiert
durch den Dateizugriff
Ermöglicht effizientes Lesen/Schreiben
grösserer Einheiten (512, 1024 Bytes, etc.)
■ Nachteile:
■
■
■
Auch wenn die Applikation nur ein Byte braucht, wird ein ganzer Block von der Datei gelesen
Lesen der ersten Bytes dauert länger
Daten werden verzögert geschrieben -> inkonsistenter Zustand;
■ -> wann soll der Puffer geschrieben werden->
■ Vorteile überwiegen bei weitem, Dateizugriff wird in modernen Betriebssystemen
und Java-Streamklassen so gehandhabt!
School of Engineering
© G. Burkert, K. Rege, ZHAW
10 von 58
Modell Datenstrom
Datei
■ Die Java Klassen modellieren
einen Datenstrom (IO Stream)
File
Datenstrom
■ Im Package java.io definiert
hello
how ..
■ Der Datenstrom puffert die Operationen
■ InputStream/OutputStream: abstrakte Oberklassen die allgemeine Ströme
beliebiger Daten repräsentieren (-> Byte Stream)
■ Read: es werden die benachbarten Bytes (Datenblock) ebenfalls gelesen
■ Write: es wird erst geschrieben wenn z.B. der Buffer voll ist
School of Engineering
© G. Burkert, K. Rege, ZHAW
11 von 58
Eingabe und Ausgabe-Ströme
InputStream
OutputStream
FileInputStream
FileOutputStream
Eingabe
allgemein
Datei
Ausgabe
■ FileInputStream/FileOutputStream: Klassen die Daten auf Datei-Ströme
beliebiger Daten repräsentieren (Byte Stream)
■ Eröffnen von Datei Eingabe Strom: Konstruktoren
■
■
fs = new FileInputStream(String name);
fs = new FileInputStream(File file);
■ Methode zum Schliessen von Strom (Schreiben aller Buffer auf Disk)
■
close(); // wichtig beim Schreiben
School of Engineering
© G. Burkert, K. Rege, ZHAW
12 von 58
FileInputStream/FileOutputStream
Datei
■ Konkrete Klasse
File
■ Erlaubt Lesen/Schreiben einzelner
(oder mehrerer) Bytes von/zu einer
Datei
Datenstrom
hello
how ..
■ Verschiedene read() und write()
Methoden für Bytes
■
werden aber eher selten direkt
verwendet
■ Constructor verlangt den Pfadnamen
des Files oder ein File Objekt
School of Engineering
© G. Burkert, K. Rege, ZHAW
13 von 58
Reader und Writer auf Zeichenströmen
School of Engineering
© G. Burkert, K. Rege, ZHAW
14 von 58
Lesen/Schreiben über Reader/Writer
Datei
Verzeichnis
File
Datenstrom
hello
InputStream
FileInputStream
how ..
Lese/Schreibkopf
OuputStream
FileOutputStream
Reader
InputStream
Reader
FileReader
Writer
OutputStream
Writer
FileWriter
■ Daten werden nicht direkt gelesen und geschrieben sondern über Reader/Writer
School of Engineering
© G. Burkert, K. Rege, ZHAW
15 von 58
Reader, InputStreamReader, FileReader
Oberklasse
Reader
allgemein
Datei
InputStreamReader
FileReader
Zeilenweise
Filter
BufferedReader
■ Reader Lesen von Zeichen-Streams (Zeichenströme)
■
■
InputStreamReader liest Bytes von einem InputStream und wandelt
sie in Zeichen um
■ FileReader liest Zeichen-Streams von einem File
BufferedReader gepuffertes Lesen, ermöglicht zeilenweises Lesen
School of Engineering
© G. Burkert, K. Rege, ZHAW
16 von 58
Writer, OutputStreamWriter FileWriter
Oberklasse
Writer
allgemein
Datei
OutputStreamWriter
FileWriter
Filter
PrintWriter
Writer Schreiben von Zeichen-Streams
OutputStreamWriter wandelt Zeichen in Bytes und gibt sie über
einen OutputStream aus
FileWriter schreibt Zeichen-Streams auf ein File
PrintWriter gepuffertes Schreiben, ermöglicht zeilenweises
Schreiben
School of Engineering
© G. Burkert, K. Rege, ZHAW
17 von 58
InputStreamReader/OutputStreamWriter
■ Erlauben die Umwandlung von ByteStreams in Zeichen-Streams
■ Die bei der Umwandlung verwendete
Codierung kann gewählt werden (Default:
lokale Codierung, bei uns ISO-8859-1)
■ Constructor verlangt einen (File-)
InputStream/OutputStream
N erst Lesen/Schreiben von
Bytes, dann Umwandlung in
Zeichens
■ Werden auch für Zugriff auf andere
Medien verwendet, z.B. Tastatur,
Bildschirm, Internet (zB Webseiten)
School of Engineering
© G. Burkert, K. Rege, ZHAW
18 von 58
Interpretation von Datenströmen
Zeichenkodierung
School of Engineering
© G. Burkert, K. Rege, ZHAW
19 von 58
Byte- und Zeichenströme
■ Objekte vom Byte-Stream-Klassen schreiben und lesen Bytes
■ Objekte vom Zeichen-Stream-Klassen schreiben und lesen Zeichen
■ In älteren Programmiersprachen ist 1 char = 1 byte!
■
7-Bit-ASCII-Code oder 8-Bit ISO 8859-1 (Latin-1)
■ In Java ist char intern immer im 16-Bit UNICODE-Format kodiert Æ
Internet-Sprache!
■ 8-Bit ISO 8859-1 Zeichensatz ist ein Subset
von Unicode (erste 256 Zeichen,
oberes Byte = 0)
Erste 256 Zeichen in Unicode
0
Upper-Byte
School of Engineering
© G. Burkert, K. Rege, ZHAW
8-Bit ISO 8859 - Code
lower-Byte
20 von 58
UTF-8
■ UTF-8-Code: Viele Texte (auch Java-Quellcode) bestehen meist nur aus Latin-1
Zeichen
■
■
16-Bit-Unicode: Platzverschwendung
UTF-8-Code: Kompakt für Latin-1
■ Vorteile
■
■
■
■
Es können alle UNICODE-Zeichen dargestellt werden
ASCII Dateien können ebenfalls problemlos gelesen und geschrieben werden
häufig benutzte Latin-1-Zeichen: nur 1 Byte-Code
selten benutzte Zeichen bis 3 Bytes
■ Problem:
■
Umwandlung Byte Stream in Zeichen Strom nicht mehr so einfach
■ es müssen 1-3 Bytes pro Zeichen gelesen/geschrieben werden
■ Lösung: Reader/Writer interpretiert den Byte-Strom und wandelt in ZeichenStrom um
School of Engineering
© G. Burkert, K. Rege, ZHAW
21 von 58
Beispiel
■ Beispiel Lesen über Streams:
String fileName = "C:\\test.txt";
char zeichen;
FileInputStream stream = new FileInputStream(fileName);
InputStreamReader inFile = new InputStreamReader (stream);
while ((zeichen = (char)inFile.read()) != -1) {
// do something...
}
stream.close();
■ Zeichenkodierung
... = new InputStreamReader (stream,"US-ASCII");
... = new InputStreamReader (stream,"ISO-8859-1");
... = new InputStreamReader (stream,"UTF-8");
School of Engineering
© G. Burkert, K. Rege, ZHAW
22 von 58
FileReader/Writer
School of Engineering
© G. Burkert, K. Rege, ZHAW
23 von 58
FileReader
■ "Convenience" Klasse
■
es muss kein Strom erzeugt werden
■ FileReader
■
erben von InputReader
zusätzliche Konstruktoren
■
FileReader(File file); erstelle Datei Leser
■ FileReader(String name); erstelle Datei Leser
close(); Methode schliesst Datei & Leser
■
■
■ Dateien können zeichenweise gelesen werden
■ Beispiel:
String fileName = "C:\test.txt";
char zeichen;
FileReader inFile = new FileReader(fileName);
while ((zeichen = (char)inFile.read()) != -1) {
// do something...
}
inFile.close();
School of Engineering
© G. Burkert, K. Rege, ZHAW
24 von 58
FileWriter
■ Dateien können zeichenweise geschrieben werden
■ FileWriter Klasse zum Schreiben von beliebigen Daten auf Datei-Ströme
(FileStream)
■
FileWriter(File file); erstelle Datei Schreiber
■
FileWriter(String name); erstelle Datei
■
FileWriter(String name, boolean app); erstelle Datei Schreiber um an Datei anzuhängen.
■
flush(); Methode schreibt Daten auf Disk
close(); Methode schliesst Datei Schreiber & Datei
■
School of Engineering
© G. Burkert, K. Rege, ZHAW
25 von 58
Reader und Writer auf Textströmen
School of Engineering
© G. Burkert, K. Rege, ZHAW
26 von 58
Text Ströme
■ Die häufigste Art von Dateien, die gelesen und geschrieben werden, sind
Textdateien
■ Sonderzeichen: ä,ö,ü ...
■ Texte haben Zeilenstruktur
■
Zeilenumbruchszeichen ist Plattformabhängig
■ Kann zwar erfragt werden
String cr = System.getProperty("line.separator");
■ Verwendung ist aber mühsam und fehleranfällig
■ Lösung -> Reader/Writer die Zeichenstrom weiter "veredeln"
School of Engineering
© G. Burkert, K. Rege, ZHAW
27 von 58
Reader/Writer Klassen für Texte
Datei
Verzeichnis
■ Lösung -> Reader/Writer die
Zeichenstrom weiter "veredeln"
File
Datenstrom
hello
how ..
Lese/Schreibkopf
Reader
InputStream
Reader
FileReader
Writer
OutputStream
Writer
FileWriter
Lese/Schreiblogik, Filter,
"Dekorierer"
BufferedReader
School of Engineering
© G. Burkert, K. Rege, ZHAW
PrintWriter
28 von 58
BufferedReader/PrinterWriter
Zeilenweises Lesen und Schreiben, meist
effizienter:
■Textdateien (und andere Medien) können
gepuffert/zeilenweise gelesen und
geschrieben werden mit den Klassen
BufferedReader und PrintWriter
■Zeilenumbruch wird transparent
gehandhabt
School of Engineering
© G. Burkert, K. Rege, ZHAW
29 von 58
BufferedReader
■ BufferedReader: gepuffertes Lesen von Zeichens aus einer Textdatei (auch
andere Medien), einzelne/mehrere Zeichen oder zeilenweise
■
■
■
■
■
BufferReader(Reader rdr); erstelle Leser
BufferReader(Reader rdr, int sz);Buffer Grösse
integer read() ; lese einzelnes Zeichen
String readLine(); lese Zeile
close(); schliesse Leser
■ Beispiel 1:
String fileName = "C:\\test.txt";
String line;
BufferedReader inFile =
new BufferedReader(new FileReader(fileName));
while((line = inFile.readLine()) != null) {
// do something...
}
inFile.close();
School of Engineering
© G. Burkert, K. Rege, ZHAW
30 von 58
BufferedReader Beispiel 2
public void actionPerformed(ActionEvent evt) {
String fileName;
String line;
if (evt.getSource() == loadButton) {
fileName = nameField.getText();
// File-Name vom Textfeld
try {
inFile = new BufferedReader(new FileReader(fileName));
inputTextArea.setText("");
// clear the input area
while( ( line = inFile.readLine() ) != null) {
inputTextArea.append(line+"\n");
}
inFile.close();
}
catch (IOException e) {
System.err.println("Error in file " + fileName +
": " + e.toString() );
System.exit(1);
}
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
31 von 58
PrintWriter
■ PrintWriter: gepuffertes Schreiben von Zeichen in eine Textdatei (auch
andere Medien), einzelne/mehrere Zeichen oder zeilenweise
■
PrintWriter(Writer wrt); erstelle Schreiber
PrintWriter(OutputStream str);
■
print(String s) ; Schreibe String
■
println(String s) ; Schreibe String & neue Zeile
■
flush(); Methode schreibt Daten auf Disk
■
close(); Methode schliesst Datei Schreiber
■
■ Beispiel
public void actionPerformed(ActionEvent evt) {
if (evt.getSource() == saveButton )
{
try{
outFile = new PrintWriter(new FileWriter("testout.txt"), true);
outFile.print(inputTextArea.getText());
outFile.close();
}
catch (IOException e)
{
...
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
32 von 58
Daten"ströme" im
Speicher - Listen
School of Engineering
© G. Burkert, K. Rege, ZHAW
33 von 58
List, ArrayList
interface
interface
List
■ Beim Array muss eine maximale Grösse
angegeben werden
■ Es gibt in Java die Datenstruktur ArrayList,
bei der einfach Elemente zur Laufzeit
hinzugefügt werden können
■
ArrayList
LinkedList
in "<" ">" wird der so. Platzhaltertyp (Generic) angegeben
■ Das volle Verständnis des Generic Konzepts ist in Java ziemlich komplex und wird nicht
besprochen
■ Deklaration
List<Student> students = new ArrayList<Student>();
■ es kann dann einfach mittels add ein neues Objekt hinzugefügt werden
students.add(s);
School of Engineering
© G. Burkert, K. Rege, ZHAW
34 von 58
… List, ArrayList
■ Anzahl Elemente in Liste
students.size();
■ Lesen eines Elements
students.get(i);
■ (Er-)Setzen eines Elements
students.set(i,s);
■ Löschen eines Elements
students.remove(i);
■ Löschen aller Elemente
students.clear();
School of Engineering
© G. Burkert, K. Rege, ZHAW
35 von 58
Serialisierung von Objekten
School of Engineering
© G. Burkert, K. Rege, ZHAW
36 von 58
Serialization von Objekten
■ Oft besteht das Bedürfnis, den aktuellen Zustand der Applikation abspeichern zu
können
■ Beispiel: Anmelde Anwendung aus dem Praktikum -> abspeichern der
Anmeldung
■ Java: Zustand ist dezentral in Objekten gespeichert -> Objekte sollten persistent
abgespeichert und wieder geladen werden können
Dies nennt man serialization/ deserialization:
■ Java bietet die Möglichkeit, Objekte in einen Byte- oder XML-Strom zu
verwandeln, der dann zum Beispiel in eine Datei gespeichert werden kann ->
Serialisierung (serialization) eines Objekts
■ Der abgespeicherte Byte-Strom kann später wieder eingelesen und daraus
wieder ein identisches Objekt erzeugt werden
-> Deserialisierung (deserialization)
School of Engineering
© G. Burkert, K. Rege, ZHAW
37 von 58
Serialization von Objekten
■ Bei der Serialisierung eines Objekts werden alle Attribute in einen Byte-Strom
verpackt
■ Falls ein Attribut eine Referenz auf ein weiteres Objekt darstellt, so wird auch
dieses Objekt serialisiert und in den Byte-Strom gepackt
■ Serialisierung dient nicht nur zur Speicherung; es können z.B. auch Objekte
zwischen Applikationen über Kommunikationsleitungen ausgetauscht werden
■ Klassen/Methoden:
■ Klasse ObjectOutputStream, Methode writeObject(Object obj) um
ein Objekt zu serialisieren
■ Klasse ObjectInputStream, Methode Object readObject() um ein
serialisiertes Objekt einzulesen
■ Damit ein Objekt serialisierbar ist, muss es das Interface Serializable
implementieren (enthält keine Methoden, zeigt nur an, dass ein Objekt
serialisierbar ist)
School of Engineering
© G. Burkert, K. Rege, ZHAW
38 von 58
Serialization von Objekten
■ Das Objekt (studlist) kann dann direkt geschrieben werden
// Write to disk with FileOutputStream
FileOutputStream f_out = new
FileOutputStream("myobject.data");
// Write object with ObjectOutputStream
ObjectOutputStream obj_out = new ObjectOutputStream (f_out);
// Write object out to disk
obj_out.writeObject ( students );
f_out.close();
School of Engineering
© G. Burkert, K. Rege, ZHAW
39 von 58
Deserialization von Objekten
■ Kann auch direkt wieder gelesen werden
// Read from disk using FileInputStream
FileInputStream f_in = new FileInputStream("myobject.data");
// Read object using ObjectInputStream
ObjectInputStream obj_in = new ObjectInputStream (f_in);
// Read an object
ArrayList<Student> students = (ArrayList<Student>) obj_in.readObject();
obj_in.close();
School of Engineering
© G. Burkert, K. Rege, ZHAW
40 von 58
Ströme von Daten über HTTP
School of Engineering
© G. Burkert, K. Rege, ZHAW
41 von 58
Remote Lesen von HTML Dokumenten
■ Lesen von Dateien über das Internet analog lokalen Dateien
■ Klasse URL
■
■
■
Klasse die URL repräsentiert (entspricht "Verzeichnis")
Konstruktor
■ URL(String urlString)
Beispiel
■ URL url= new URL("http://www.zhaw.ch");
■ Klasse URLConnection (entspricht "Datei")
■
URLConnection link;
■
wird von URL zurückgegeben
■ link = url.openConnection();
■
liefert InputStream
■ inputStream inStream;
■ inStream = link.getInputStream();
■ diese Klassen brauchen zusätzlich
■
import java.net.*;
School of Engineering
© G. Burkert, K. Rege, ZHAW
42 von 58
Bsp: Lesen der ZHAW Homepage
import java.net.*; ...
Deklaration und Instanziierung
von URL und URLConnection
try {
URL url = new URL("http://www.zhaw.ch");
URLConnection link = url.openConnection();
InputStream inStream = link.getInputStream();
InputStreamReader inStrRrd
Deklaration und Instanziierung
Stream & Reader
= new InputStreamReader(inStream);
BufferedReader inRdr = new BufferedReader(inStrRrd);
Lesen
String line;
while ((line = inRdr.readLine()) != null) {
System.out.println(line);
}
inRdr.close();
Schliessen der Verbindung
}
catch(IOException ex) {System.out.println(ex.getMessage());}
catch(Exception ex) {System.out.println(ex.getMessage());}
School of Engineering
© G. Burkert, K. Rege, ZHAW
43 von 58
Serielle Kommunikation mit Arduino
import java.io.*;
import gnu.io.*;
...
private BufferedReader input;
/** The output stream to the port */
private OutputStream output;
// open serial port, and use class name for the appName.
SerialPort
serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);
// set port parameters
serialPort.setSerialPortParams(DATA_RATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
SerialPort.PARITY_NONE);
// open the streams
input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));
output = serialPort.getOutputStream();
...
http://playground.arduino.cc/Interfacing/Java
School of Engineering
© G. Burkert, K. Rege, ZHAW
44 von 58
Zusammenfassung Ströme
■ in Java wird zwischen Trägern, Strömen, Lese/Schreibern und Filtern
unterschieden
■ Klassen von "Medien" sind:
■ File
■ URLConnection
■ Klassen von Strömen sind
■ InputStream, FileInputStream
■ OutputStream, FileOutputStream
■ Klassen von Lesern
■ Reader, InputStreamReader, FileReader
■ Klassen von Schreibern
■ Writer, OutputStreamWriter, FileWriter
■ Klassen von "veredelten" Lesern/Schreibern sind
■ BufferedReader, PrintWriter
School of Engineering
© G. Burkert, K. Rege, ZHAW
45 von 58
Noch Fragen?
School of Engineering
© G. Burkert, K. Rege, ZHAW
46 von 58
Anhang: Einlesen von einem File
import java.io.*;
…...
Deklaration & Erzeugung der Reader
String fileName = "datei.txt";
try {
FileReader inFileReader = new FileReader(fileName);
BufferedReader inReader = new BufferedReader( inFileReader );
String line;
while((line = inReader.readLine()) != null) {
Zeilenweise Einlesen
System.out.println(line);
null-> Dateiende
}
inReader.close();
Schliessen des Readers
}
catch (IOException e) {
System.err.println("Error in file " +
fileName + ": " + e.getMessage() );
Fehlerbehandlung
}
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
47 von 58
Anhang: einer Ausgabe auf eine Datei
import java.io.*;
…...
Deklaration & Erzeugung der Schreiber
try{
FileWriter fWrt=new FileWriter("testout.txt");
PrintWriter outWrt=new PrintWriter(fwrt);
for (int i = 0; i < 10; i++) {
outWrt .println( "Zeile " + i);
}
Schliessen des Schreibers
outWrt .close();
}
catch (IOException e) {
Fehlerbehandlung
System.err.println("File Error: " +
e.getMessage() );
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
48 von 58
Anhang: Wert in CSV-Datei suchen
try {
String line;
String[] items;
boolean found = false;
BufferedReader inFile = new BufferedReader(new FileReader(fileName));
while (( ( line = inFile.readLine() ) != null) && (! found)) {
// tokens split on commas, semicolons
items = line.split("[;,]+");
if (personField.getText().equals(items[0])) {
found = true;
result1Field.setText(items[1]);
result2Field.setText(items[2]);
}
}
inFile.close();
}
catch (IOException e) {
System.err.println("Error reading file "+fileName+": "+e.toString());
}
School of Engineering
© G. Burkert, K. Rege, ZHAW
49 von 58
Standard Dialoge, z.B. JFileChooser
■ Erzeugt Dialog-Fenster, um ein File
auszuwählen
■ Deklaration:
■ Weitere Einstellungsmöglichkeiten
■
Filter, Directory, …
private JFileChooser fc;
■ Initialisierung:
fc = new JFileChooser();
int returnVal =
fc.showOpenDialog(this);
oder
int returnVal =
fc.showSaveDialog(this);
■ Verarbeitung:
if (returnVal == JFileChooser.APPROVE_OPTION) {
…// ok
}
else {System.out.println("canceled");}
■ Ausgewähltes File:
File file = fc.getSelectedFile();
■ Pfad des ausgewählten Files:
String path
fc.getSelectedFile().getAbsolutePath();
School of Engineering
© G. Burkert, K. Rege, ZHAW
50 von 58
Konsolen-IO
School of Engineering
© G. Burkert, K. Rege, ZHAW
51 von 58
Konsolen-IO
"Once upon a time, in the very beginning of the computer era…"
Historische Entwicklung von User-Interfaces:
■Am Anfang gab es nur Konsolen/Terminals
■
■
■
Ein-/Ausgabe war nur textbasiert möglich
Eingabe per Lochkarte oder Keyboard
Ausgabe auf Lineprinter/Bildschirm
■Später: einfache, textuelle Menüs; Auswahl aus einer Befehls-Liste via CursorTasten
■Erst später: graphische Benützerschnittstellen (GUI) mit Eingabe per Maus
School of Engineering
© G. Burkert, K. Rege, ZHAW
52 von 58
Konsolen-IO
■Software mit Kommandozeilen-Interface sind aber auch heute noch sehr
verbreitet (Linux, UNIX, teilweise auch Windows)
■Diverse Vorteile im Vergleich zu GUIs:
■
■
■
Sehr effizient bedienbar (wenn man „drauskommt“...)
Piping: der Output von einem Programm wird in einem anderen als Input verwenden: ls –la | grep
demo
Ausführen von Skripts und damit das Automatisieren von sich wiederholenden Tasks (z.B. Online
Backup einer Oracle DB)
Konsolen-IO: Eingabe/Ausgabe von Programmen über die Konsole
■Aus Sicht der Applikation 3 wichtige „Ein-/Ausgabekanäle“:
■
■
Standard Input,
Output und Error
Per Default alles auf
der Konsole, können
umgeleitet werden
stdout
stdin
Programm
(Kanal Nr. 0)
(Kanal Nr.1)
stderr
(Kanal Nr.2)
■In Java sind Kommandozeilen-Interfaces einfach realisierbar mit speziellen
Streams, die in der System-Klasse bereits vordefiniert sind
School of Engineering
© G. Burkert, K. Rege, ZHAW
53 von 58
System-Klasse
■ Stellt eine plattformunabhängige Schnittstelle zu einigen
Betriebssystemfunktionen zur Verfügung
■ Sie enthält nur Klassenvariablen und Klassenmethoden
■ Sie kann nicht instanziert werden
■Sie stellt unter anderem 3 Streams zur Verfügung:
■
■
■
System.in
System.out
System.err
School of Engineering
(->Standard Input)
(->Standard Output)
(->Standard Error)
© G. Burkert, K. Rege, ZHAW
54 von 58
System.out
■ System.out
■
ist ein PrintStream (Klasse wurde ab Java 1.1 ersetzt durch PrintWriter): ähnliche
Schnittstelle wie PrintWriter
■ Methoden
■
■
■
■
print(String str)
println(String str)
Kein automatisches flush!
analoge Methoden für int, float, ...,
System.out.flush() leert Puffer nach print.
■ Für Einfache- und Testausgabe
■
System.out.println("Ausgabe");
■ Für Programm-Prompts mit Benützereingabe auf der gleichen Zeile.
■ muss nicht mit new erzeugt werden, er existiert schon
School of Engineering
© G. Burkert, K. Rege, ZHAW
55 von 58
System.in
■ System.in
■
Ein InputStream-Objekt
■ Wird für das direkte Einlesen von Tastatureingaben oder dem Einlesen des
Outputs eines anderen Programms (via Piping) verwendet
■ Erlaubt nur byteweises einlesen von Daten -> komfortabler mit einem
BufferedReader:
BufferedReader keyboard;
System.out.print(message);
System.out.flush();
keyboard = new BufferedReader(
new InputStreamReader(System.in), 1);
String line = keyboard.readLine();
■
Puffergrösse wird hier auf 1 gesetzt, damit keine Verzögerungen bei einem readLine() entstehen
School of Engineering
© G. Burkert, K. Rege, ZHAW
56 von 58
System.err / System.exit
System.err
■Wird gebraucht zur Ausgabe von Fehlermeldungen auf die Konsole, Piping
funktioniert nicht mit System.err
■Prinzipiell wie System.out, aber dieser Strom kann nicht mit Piping verwendet
werden
System.exit
■Methode System.exit(int errorCode) beendet eine Applikation sofort und gibt
errorCode an das Betriebssystem zurück
■Konvention für errorCode:
■
■
System.exit(0); // 0 Normale Beendigung
System.exit(2); // <>0 Abbruch nach Fehler
School of Engineering
© G. Burkert, K. Rege, ZHAW
57 von 58
Umleiten/Redirecting
■ Standard Input, Output und Error können
umgeleitet werden
■ Funktioniert für alle Command-LineTools/Programme (nicht nur Java)
■ Das Programm selbst „merkt nichts davon“
stderr
Tastatur
Datei
in.dat
stdin
<in.dat
Programm
Programm
myprog.exe
myprog.exe
stdout
>out.dat
Bildschirm
Datei
out.dat
■ Beispiel mit Java-Programm Programm:
■
■
■
■
java Programm
// Alles über Konsole
java Programm > output.txt // Output ins File output.txt
java Programm 2> error.txt // Fehler ins File error.txt
java programm < input.txt // Input aus File input.txt
■ Macht Programme enorm flexibel: eine Personenliste kann z.B. eingegeben
werden oder aus einem File gelesen werden g das Programm wird unabhängig
davon entwickelt
■ Ist Voraussetzung für Piping: die Personenliste kann damit auch von einem
anderen Programm kommen:
java Personenliste | java Programm
School of Engineering
© G. Burkert, K. Rege, ZHAW
■
58 von 58