Dateien, Ströme

Dateien, Ströme
Einführung
■ 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
School of Engineering
Datei/File
■
■Zugriffsrechte auf Dateien
Daten im Arbeitsspeicher (RAM) gehen beim Ausschalten des Computers verloren
Wir brauchen eine Möglichkeit, um diese Daten permanent zu speichern
■ J zusammengehörige Daten werden zu Dateien (Eng: File = Ablage) zusammengefasst
und als eine Einheit behandelt
■
■
■
■
■
■
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
■
Normalerweise hat der Benützer uneingeschränkte Zugriffsrechte auf Dateien (lesen, schreiben,
umbenennen, löschen, ausführen)
Die Zugriffsrechte können vom Besitzer der Datei weiter eingeschränkt werden
Einhaltung der Zugriffsrechte wird vom Betriebssystem garantiert
■Applets
■ Datei
■
2 von 50
Zugriffsrechte
■ Problem
■
© A. Meier/M. Braschler/J. Zeman/K. Rege
© A. Meier/M. Braschler/J. Zeman/K. Rege
3 von 50
■
Haben keine Zugriffsrechte auf Files des Computers, auf dem das Applet läuft J wieso?
Mit einer entsprechend eingestellten Security-Policy können Applets jedoch auch auf Files
zugreifen (für JNI schon gemacht).
■Java Applikationen
■
■
Eine Java Applikation hat die Rechte des Benützers, der sie ausführt
Keine weiteren Einschränkungen bezüglich Zugriffsrechten
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
4 von 50
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);
■
■
Files in Java
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
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
5 von 50
■
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
Die Klasse File
Standard Dialoge, z.B. JFileChooser
■ Methoden zur Verzeichnisdurchsuche
■ Erzeugt Dialog-Fenster, um ein File
auszuwählen
■
String[] list() : retourniert Liste aller Dateien
6 von 50
■ Weitere Einstellungsmöglichkeiten
■
Filter, Directory, …
■ Deklaration:
■ Methode zur Dateiumbenennung/Löschung
■
■
private JFileChooser fc;
■ Initialisierung:
boolean renameTo(File dest) : benennt File um
boolean delete() : löscht Datei; true -> war vorhanden
fc = new JFileChooser();
int returnVal = fc.showOpenDialog(this);
oder
■ Beispiel: Auflisten von Windows Verzeichnis
int returnVal =
fc.showSaveDialog(this);
File dir = new File("C:\\windows");
■ Verarbeitung:
String[] dirNames = dir.list();
if (returnVal == JFileChooser.APPROVE_OPTION) {
….// ok
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);
}
else {System.out.println("canceled");}
■ Ausgewähltes File:
File file = fc.getSelectedFile();
■ Pfad des ausgewählten Files:
}
String path =
fc.getSelectedFile().getPath();
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
7 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
8 von 50
Dateizugriff: stream oder random access?
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
Dateizugriffsströme
■ 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
© A. Meier/M. Braschler/J. Zeman/K. Rege
9 von 50
Direkter sequentieller Dateizugriff
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
10 von 50
Gepufferter sequentieller Zugriff
■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:
■Daten werden blockweise gelesen/
geschrieben, Zwischenspeicherung im
Arbeitsspeicher
■Vorteile:
■
■Direkter sequentieller Zugriff:
■
■
Daten werden Byte für Byte gelesen/geschrieben J Datenstrom (Stream)
Vorteil: maximale Kontrolle des
Programmierers, denn Daten werden
unmittelbar auf/von Datei geschrieben/
gelesen
■
■Nachteile:
■
■
■
Nachteile: langsam, Applikation wird
jedesmal blockiert, bis das Byte gelesen/
geschrieben ist
J 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
© A. Meier/M. Braschler/J. Zeman/K. Rege
Die Applikation ist weniger blockiert
durch den Dateizugriff
Ermöglicht effizientes Lesen/Schreiben
grösserer Einheiten (512, 1024 Bytes, etc.)
■
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 J inkonsistenter Zustand;
■ -> wann soll der Puffer geschrieben werden?
■Vorteile überwiegen bei weitem, Dateizugriff wird in modernen
Betriebssystemen und Java-Streamklassen so gehandhabt!
11 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
12 von 50
Modell Datenstrom
Eingabe und Ausgabe-Ströme
Datei
■ Die Java Klassen modellieren
einen Datenstrom (IO Stream)
File
Datenstrom
■ Im Package java.io definiert
hello
InputStream
OutputStream
FileInputStream
FileOutputStream
allgemein
how ..
Eingabe
Datei
Ausgabe
■ Der Datenstrom puffert die Operationen
■ FileInputStream/FileOutputStream: Klassen die Daten auf Datei-Ströme
■ InputStream/OutputStream: abstrakte Oberklassen die allgemeine Ströme
beliebiger Daten repräsentieren (-> Byte Stream)
beliebiger Daten repräsentieren (Byte Stream)
■ Eröffnen von Datei Eingabe Strom: Konstruktoren
■
■ Read: es werden die benachbarten Bytes (Datenblock) ebenfalls gelesen
■
fs = new FileInputStream(String name);
fs = new FileInputStream(File file);
■ Methode zum Schliessen von Strom (Schreiben aller Buffer auf Disk)
■
■ Write: es wird erst geschrieben wenn z.B. der Buffer voll ist
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
13 von 50
close(); // wichtig beim Schreiben
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
14 von 50
FileInputStream/
FileInputStream/FileOutputStream
Datei
■ Konkrete Klasse
File
■ Erlaubt Lesen/Schreiben einzelner
(oder mehrerer) Bytes von/zu einer
Datei
Datenstrom
hello
how ..
■ Verschiedene read() und write()
Interpretation von Datenströmen
Zeichenkodierung
Methoden für Bytes
■
werden aber eher selten direkt
verwendet
■ Constructor verlangt den Pfadnamen
des Files oder ein File Objekt
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
15 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
16 von 50
Byte- und Zeichenströ
Zeichenströme
UTF-8
■ UTF-8-Code: Viele Texte (auch Java-Quellcode) bestehen meist nur aus Latin-1
Zeichen
■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!
■
■
16-Bit-Unicode: Platzverschwendung
UTF-8-Code: Kompakt für Latin-1
7-Bit-ASCII-Code oder 8-Bit ISO 8859-1 (Latin-1)
■ Vorteile
■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
■ Problem:
■
0
8-Bit ISO 8859 - Code
Upper-Byte
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
Umwandlung Byte Stream in Zeichen Strom nicht mehr so einfach
■ es müssen 1-3 Bytes pro Zeichen gelesen/geschrieben werden
lower-Byte
■ Lösung: Reader/Writer interpretiert den Byte-Strom und wandelt in ZeichenStrom um
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
17 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
18 von 50
Lesen/Schreiben über Reader/Writer
Datei
Verzeichnis
File
Datenstrom
hello
InputStream
Reader und Writer auf Zeichenströmen
FileInputStream
OuputStream
FileOutputStream
how ..
Lese/Schreibkopf
Reader
InputStream
Reader
FileReader
Writer
OutputStream
Writer
FileWriter
■ Daten werden nicht direkt gelesen und geschrieben sondern über Reader/Writer
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
19 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
20 von 50
Reader, InputStreamReader, FileReader
Writer, OutputStreamWriter FileWriter
Oberklasse
Oberklasse
Reader
allgemein
Datei
InputStreamReader
Writer
allgemein
Datei
OutputStreamWriter
FileWriter
FileReader
Filter
Zeilenweise
Filter
PrintWriter
BufferedReader
■ Writer Schreiben von Zeichen-Streams
■ 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
■
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
21 von 50
InputStreamReader/
InputStreamReader/OutputStreamWriter
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
22 von 50
Beispiel
■ Beispiel Lesen über Streams:
■ Erlauben die Umwandlung von ByteStreams in Zeichen-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();
■ Die bei der Umwandlung verwendete
Codierung kann gewählt werden
(Default: lokale Codierung, bei uns ISO8859-1)
■ Constructor verlangt einen (File-)
InputStream/OutputStream J erst
Lesen/Schreiben von Bytes, dann
Umwandlung in Zeichens
■ Zeichenkodierung
... = new InputStreamReader (stream,"US-ASCII");
■ Werden auch für Zugriff auf andere
Medien verwendet, z.B. Tastatur,
Bildschirm, Internet (zB Webseiten)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
... = new InputStreamReader (stream,"ISO-8859-1");
... = new InputStreamReader (stream,"UTF-8");
23 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
24 von 50
FileReader
FileWriter
■ Dateien können zeichenweise geschrieben werden
■"Convenience" Klasse
■
es muss kein Strom erzeugt werden
■ FileWriter Klasse zum Schreiben von beliebigen Daten auf Datei-Ströme
■FileReader
■
■
■
(FileStream)
erben von InputReader
zusätzliche Konstruktoren
■ FileReader(File file); erstelle Datei Leser
■ FileReader(String name); erstelle Datei Leser
close(); Methode schliesst Datei & Leser
■
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
■
■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
© A. Meier/M. Braschler/J. Zeman/K. Rege
25 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
26 von 50
Text Strö
Ströme
■Die häufigste Art von Dateien, die gelesen und geschrieben werden, sind
Textdateien
■Texte haben Zeilenstruktur
■
Reader und Writer auf Textströmen
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
27 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
28 von 50
BufferedReader/
BufferedReader/PrinterWriter
Reader/Writer Klassen für Texte
Datei
Verzeichnis
Zeilenweises Lesen und Schreiben, meist
effizienter:
File
■ Lösung -> Reader/Writer die
Zeichenstrom weiter "veredeln"
Datenstrom
hello
■ Der Gebrauch dieser Klassen ist
bei Textdateien eigentlich immer sinnvoll!
how ..
■ Textdateien (und andere Medien) können
gepuffert/zeilenweise gelesen und
geschrieben werden mit den Klassen
BufferedReader und PrintWriter
Lese/Schreibkopf
Reader
InputStream
Reader
FileReader
Writer
OutputStream
Writer
■ Zeilenumbruch wird transparent
gehandhabt
FileWriter
Lese/Schreiblogik, Filter,
"Dekorierer"
BufferedReader
School of Engineering
PrintWriter
© A. Meier/M. Braschler/J. Zeman/K. Rege
29 von 50
BufferedReader
© A. Meier/M. Braschler/J. Zeman/K. Rege
30 von 50
BufferedReader Beispiel 2
■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:
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
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
31 von 50
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
32 von 50
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
■
Serialisierung von Objekten
■ 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
© A. Meier/M. Braschler/J. Zeman/K. Rege
33 von 50
Serialization von Objekten
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
34 von 50
Serialization
■Oft besteht das Bedürfnis, den aktuellen Zustand der Applikation abspeichern
zu können
■Bei der Serialisierung eines Objekts werden alle Attribute in einen Byte-Strom
verpackt
■Beispiel: Anmelde Anwendung aus dem Praktikum J abspeichern der
Anmeldung
■Falls ein Attribut eine Referenz auf ein weiteres Objekt darstellt, so wird auch
dieses Objekt serialisiert und in den Byte-Strom gepackt
■Java: Zustand ist dezentral in Objekten gespeichert J Objekte sollten persistent
abgespeichert und wieder geladen werden können
■Serialisierung dient nicht nur zur Speicherung; es können z.B. auch Objekte
zwischen Applikationen über Kommunikationsleitungen ausgetauscht werden
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 J
Serialisierung (serialization) eines Objekts
■Der abgespeicherte Byte-Strom kann später wieder eingelesen und daraus
wieder ein identisches Objekt erzeugt werden
J Deserialisierung (deserialization)
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
35 von 50
■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
© A. Meier/M. Braschler/J. Zeman/K. Rege
36 von 50
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
■
■
Konsolen-IO
■
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
37 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
38 von 50
System-Klasse
Konsolen-IO
■Software mit Kommandozeilen-Interface sind aber auch heute noch sehr
verbreitet (Linux, UNIX, teilweise auch Windows)
■ Stellt eine plattformunabhängige Schnittstelle zu einigen
Betriebssystemfunktionen zur Verfügung
■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)
■ Sie enthält nur Klassenvariablen und Klassenmethoden
■ Sie kann nicht instanziert werden
Konsolen-IO: Eingabe/Ausgabe von Programmen über die Konsole
■Sie stellt unter anderem 3 Streams zur Verfügung:
■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
System.in
System.out
System.err
(= Standard Input)
(= Standard Output)
(= Standard Error)
(Kanal Nr.2)
■In Java sind Kommandozeilen-Interfaces einfach realisierbar mit speziellen
Streams, die in der System-Klasse bereits vordefiniert sind
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
39 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
40 von 50
System.out
System.in
■ System.out
■System.in
■
ist ein PrintStream (Klasse wurde ab Java 1.1 ersetzt durch PrintWriter): ähnliche
Schnittstelle wie PrintWriter
■ Methoden
■
■
■
■
print(String str)
println(String str)
■
kein
keinflush!
flush!
analoge Methoden für int, float, ...,
System.out.flush() leert Puffer nach print.
■ Erlaubt nur byteweises einlesen von Daten J komfortabler mit einem
BufferedReader:
■ Für Einfache- und Testausgabe
■
BufferedReader keyboard;
System.out.print(message);
System.out.flush();
keyboard = new BufferedReader(
new InputStreamReader(System.in), 1);
String line = keyboard.readLine();
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
© A. Meier/M. Braschler/J. Zeman/K. Rege
Ein InputStream-Objekt
■ Wird für das direkte Einlesen von Tastatureingaben oder dem Einlesen des
Outputs eines anderen Programms (via Piping) verwendet
41 von 50
System.err
System.err / System.exit
System.exit
Puffergrösse wird hier auf 1 gesetzt, damit keine Verzögerungen bei einem readLine()
entstehen
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
42 von 50
Umleiten/Redirecting
Umleiten/Redirecting
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
■Funktioniert für alle Command-LineTools/Programme (nicht nur Java)
■Das Programm selbst „merkt nichts davon“
werden
Geräte
Gerätefür
fürdie
die
Standard-IO-Kanäle
Standard-IO-Kanäle
■Standard Input, Output und Error können
umgeleitet werden
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:
■
System.exit
java
java
■ java
■ java
■
■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
© A. Meier/M. Braschler/J. Zeman/K. Rege
// Alles über Konsole
// Output ins File output.txt
// Fehler ins File error.txt
// Input aus File input.txt
■Macht Programme enorm flexibel: eine Personenliste kann z.B. eingegeben
werden oder aus einem File gelesen werden J das Programm wird unabhängig
davon entwickelt
■Ist Voraussetzung für Piping: die Personenliste kann damit auch von einem
anderen Programm kommen:
■
School of Engineering
Programm
Programm > output.txt
Programm 2> error.txt
programm < input.txt
43 von 50
java Personenliste | java Programm
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
44 von 50
Remote Lesen von HTML Dokumenten
■ Lesen von Dateien über das Internet analog lokalen Dateien
■ Klasse URL
■
■
■
Ströme von Daten über HTTP
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
■
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
45 von 50
Bsp: Lesen der ZHAW Homepage
try {
■ Klassen von "Medien" sind:
■ File
■ URLConnection
Deklaration und Instanziierung
Deklaration und Instanziierung
Stream & Reader
InputStream inStream = link.getInputStream(); Stream & Reader
URLConnection link = url.openConnection();
= new InputStreamReader(inStream);
■ Klassen von Strömen sind
■ InputStream, FileInputStream
■ OutputStream, FileOutputStream
BufferedReader inRdr = new BufferedReader(inStrRrd);
Lesen
Lesen
String line;
while ((line = inRdr.readLine()) != null) {
■ Klassen von Lesern
■ Reader, InputStreamReader, FileReader
System.out.println(line);
}
inRdr.close();
■ Klassen von Schreibern
■ Writer, OutputStreamWriter, FileWriter
Schliessen der Verbindung
Schliessen der Verbindung
}
catch(IOException ex) {System.out.println(ex.getMessage());}
■ Klassen von "veredelten" Lesern/Schreibern sind
■ BufferedReader, PrintWriter
catch(Exception ex) {System.out.println(ex.getMessage());}
School of Engineering
46 von 50
■ in Java wird zwischen Trägern, Strömen, Lese/Schreibern und Filtern
unterschieden
URL url = new URL("http://www.zhaw.ch");
InputStreamReader inStrRrd
© A. Meier/M. Braschler/J. Zeman/K. Rege
Zusammenfassung Ströme
Deklaration
Deklarationund
undInstanziierung
Instanziierungvon
von
URL
URLund
undURLConnection
URLConnection
import java.net.*; ...
import java.net.*;
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
47 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
48 von 50
Anhang: Einlesen von einem File
Anhang: einer Ausgabe auf eine Datei
import java.io.*;
…...
Deklaration
Deklaration&&Erzeugung
Erzeugungder
derReader
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
Zeilenweise Einlesen
System.out.println(line);
null-> Dateiende
null-> Dateiende
}
inReader.close();
Schliessen des Readers
Schliessen des Readers
}
catch (IOException e) {
System.err.println("Error in file " +
fileName + ": " + e.getMessage() );
Fehlerbehandlung
Fehlerbehandlung
}
}
…...
import java.io.*;
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
Deklaration
Deklaration&&Erzeugung
Erzeugungder
derSchreiber
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
Schliessendes
desSchreibers
Schreibers
outWrt .close();
}
catch (IOException e) {
Fehlerbehandlung
Fehlerbehandlung
System.err.println("File Error: " +
e.getMessage() );
}
49 von 50
School of Engineering
© A. Meier/M. Braschler/J. Zeman/K. Rege
50 von 50