Embed Size (px)
Citation preview
Seite 1
CS1005Objektorientierte Programmierung Bachelor of Science (Informatik)
Dateien – Konzept, Verwendungsbeispiele – Textdateien und ihre Analyse – Binärdateien
Thomas Letschert
Seite 2
Dateien - Konzept
Datei
Externer Datenspeicher
CPU Ausführung von ProgrammenHauptspeicher Programmcode und -Daten, direkt zugreifbar von CPU
externe Speicher Festplatte etc.: nur indirekt zugreifbar über Betriebssystem- Aufrufe
Programmausführung Programm-Code und -Daten
Intern Extern
Betriebssystem
CPU / Prozessor HauptspeicherCPU / ProzessorFestplatte
Seite 3
Dateien - Konzept
Datei – rein virtuelles Konstrukt: realisiert auf verschiedenen
Abstraktionsebenen
Platte: Magnetisierte Spuren, in Zylinder organisiert
Plattencontroller: nummerierte Datenblöcke (von jeweils z.B. 512 Byte)
Betriebssystem: (BS-) Datei = (scheinbar) zusammenhängender beliebig und variabel großer Datenbereich, nach Konventionen des Betriebssystems nutzbar
Programm: (Programm-) Datei = (scheinbar) zusammenhängenderbeliebig und variabel großer Datenbereich,nach Konventionen der Programmiersprache nutzbar
Ababdahuwediuhw
Betriebssystem
Programm-API
Programm
Programmdatei(Programminterne Repräsentation.)
BS-Datei(BS-internere Rep.)
DatenSystemaufruf
Seite 4
Dateien - Konzept
Datei-Repräsentant in Java
bis Java 1.6: java.io.File
ab Java 1.7: java.nio.file.Path
Ababdahuwediuh
Betriebssystem
Programm-API
Programm
Ab Java 7 stehen beide Varianten zur Verfügung. Es sollte aber i.A. die neuere Variante java.nio.file.Path verwendet werden.Gelegentlich muss aber auch bei Java 7 auf die Klasse java.io.File zurück gegriffen werden. (z.B. bei Verwendung des FileChooser.)
Seite 5
Dateien - Konzept
Datei-Klassen in Java 7
java.nio.file.Path ein Ort im Dateisystem: Pfad zu einer Datei oder einem Verzeichnis An diesem Ort muss nicht zwingend eine Datei oder ein Verzeichnis existieren
java.nio.file.Paths statische Klasse mit Hilfsfunktionen für Path-Objekte nicht sehr wichtige Klasse
java.io.File Datei oder Verzeichnis Repräsentiert eine existierende Datei oder ein existierendes Verzeichnis
java.io.Files statische Klasse mit Hilfsfunktionen für File-Objekte Funktionen in dieser Klasse realisieren Operationen im realen Dateisystem
Seite 6
Dateien – Verwendung / lesen
Datei-Inhalt zeilenweise – mit der Klasse Scanner – lesen
import java.io.File;import java.io.FileNotFoundException;import java.util.Scanner;
public class Read_V6 {
public static void main(String[] args) throws FileNotFoundException {
File f = new File("blubber.txt"); Scanner scan = new Scanner(f); while (scan.hasNextLine()) { System.out.println(scan.nextLine()); } }}
import java.io.IOException;import java.nio.file.Path;import java.nio.file.Paths;import java.util.Scanner;
public class Read_V7 {
public static void main(String[] args) throws IOException {
Path p = Paths.get("blubber.txt"); Scanner scan = new Scanner(p); while (scan.hasNextLine()) { System.out.println(scan.nextLine()); } }}
ab Java 1.7
Java alle Versionen
Seite 7
Dateien – Verwendung / lesen
Datei-Inhalt zeilenweise einlesen
ab Java 1.7
java.nio.file.Paths
ist eine Helferklasse mit Nützlichem in Bezug auf Datei-Operationen.
java.nio.file.Files
ist eine Helferklasse mit allerlei Nützlichem in Bezug auf Datei-Verarbeitung.
public static void main(String[] args) { Path path = Paths.get("/home/thomas/tmp/test.txt");
try { BufferedReader reader = Files.newBufferedReader(path,StandardCharsets.UTF_8);String line;int i = 0;while ((line = reader.readLine()) != null) {
System.out.println("Zeile "+ ++i + " "+ line);}
} catch (IOException e) { System.err.println(e);
}}
Seite 8
import java.io.IOException;import java.nio.charset.Charset;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;
public class Read_V7_a {
public static void main(String[] args) throws IOException { Path path = Paths.get("test.txt");
int i = 0; for ( String line: Files.readAllLines(
path, Charset.defaultCharset()) ) {
System.out.println("Zeile "+ ++i + line); } System.out.println("Die Datei enthält " + i + " Zeilen"); }
}
Dateien – Verwendung / lesen
Datei-Inhalt zeilenweise einlesen – etwas kompakter
ab Java 1.7
Seite 9
Dateien – Verwendung / lesen
Datei-Inhalt zeilenweise einlesen – als Liste von Zeilen
ab Java 1.7
import java.io.IOException;import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.util.List;
public class ReadWrite {
public static void main(String[] args) { Path path = Paths.get("/home/thomas/tmp/test.txt");
try {int i = 0;
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
for (String line: lines) {System.out.println("Zeile "+ ++i + " "+ line);
} } catch (IOException e) {
System.err.println(e); } }
}
Charset.defaultCharset() : Zeichensatz des Systems
StandardCharsets.UTF_8 : Zeichensatz UTF-8
Seite 10
Dateien – Verwendung / lesen
Datei-Inhalt komplett als String einlesen
ab Java 1.7
import java.io.IOException;import java.nio.charset.Charset;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;
public class Read_V7_b {
public static void main(String[] args) throws IOException {
Path path = Paths.get("blubber.txt");
String content = new String(Files.readAllBytes(path), Charset.defaultCharset());
System.out.println(content); }
}
Verwendet aus der Klasse Files: byte[] readAllBytes(Path path)
und den Konstruktor der Klasse String: String(byte[] bytes, Charset charset)
Seite 11
Dateien – Verwendung / Auswahl
Datei-Auswahl mit Auswahldialog – Java 6 Variante
import java.io.File;import java.io.FileNotFoundException;import java.util.Scanner;
import javax.swing.JFileChooser;
public class Choose_V6 {
public static void main(String[] args) throws FileNotFoundException {
File f = null;
JFileChooser fc = new JFileChooser(); int chooseResult = fc.showDialog(null, "Bitte Datei auswählen"); if (chooseResult == JFileChooser.APPROVE_OPTION) { f = fc.getSelectedFile(); }
if (f != null) { Scanner scan = new Scanner(f); while (scan.hasNextLine()) { System.out.println(scan.nextLine()); } } }
}
Seite 12
Dateien – Verwendung / Auswahl
Datei-Auswahl mit Auswahldialog – Java 7 Variante
import java.io.File;import java.io.IOException;import java.nio.file.Path;import java.util.Scanner;
import javax.swing.JFileChooser;
public class Choose_V7 {
public static void main(String[] args) throws IOException {
File f = null; JFileChooser fc = new JFileChooser(); int chooseResult = fc.showDialog(null, "Bitte Datei auswählen"); if (chooseResult == JFileChooser.APPROVE_OPTION) { f = fc.getSelectedFile(); } if (f != null) { Path p = f.toPath(); Scanner scan = new Scanner(p); while (scan.hasNextLine()) { System.out.println(scan.nextLine()); } } }
}
Wechsel zwischen den V-6 und V-7 Repräsentanten:
Path path = file.toPath()File file = path.toFile();
Seite 13
Dateien – Verwendung / schreiben
Datei schreiben – Java 6 Variante
import java.io.FileWriter;import java.io.IOException;import java.io.PrintWriter;
public class Write_V6 {
public static void main(String[] args) throws IOException { String filePath = "balbla.txt";
PrintWriter pw = new PrintWriter(new FileWriter(filePath));
pw.println("Hallo"); pw.println("Welt!"); pw.close(); }
}
Datei schließen nicht vergessen!
Datei mit Printwriter verbinden
Seite 14
Dateien – Verwendung / schreiben
Datei schreiben – Java 7 Variante 1
import java.io.IOException;import java.io.PrintWriter;import java.nio.charset.Charset;import java.nio.file.Files;import java.nio.file.Paths;
public class Write_V7 {
public static void main(String[] args) throws IOException { String filePath = "balbla.txt";
PrintWriter pw = new PrintWriter( Files.newBufferedWriter(
Paths.get(filePath), Charset.defaultCharset()));
pw.println("Hallo\n"); pw.println("Welt!\n"); pw.close(); }
}
Angabe in welchem Zeichensatz der Text codiert werden soll. Z.B: Zeichensatz des Systems oder UTF-8
- Charset.defaultCharset() - Charset.forName("UTF-8"))
Datei mit Printwriter verbinden
Seite 15
Dateien – Verwendung / schreiben
Datei schreiben – Java 7 Variante 2
import java.io.BufferedWriter;import java.io.IOException;import java.nio.charset.StandardCharsets;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.nio.file.StandardOpenOption;
public class ReadWrite {
public static void main(String[] args) {
Path path = Paths.get("/home/hugo/tmp/blabla.txt");
try {BufferedWriter writer = Files.newBufferedWriter(
path,StandardCharsets.UTF_8,StandardOpenOption.WRITE );
int i = 0; while (i < 10) {
writer.write("Zeile "+ ++i + " "+ "blaba blubber " + "\n");}writer.close();
} catch (IOException e) {System.err.println(e);
} }
}
Mit diesem Parameter wird die Datei nur beschrieben wenn sie bereits existiert, fehlt er, dann wird die Datei auch bei Bedarf erzeugt.
Seite 16
Dateien – Verwendung / schreiben
Datei schreiben – Java 7 Variante 3Hallo Welt!
Hallo Welt!Das ist ein zusätzlicher TextMit Zeilenvorschub!
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.nio.file.StandardOpenOption;
public class Write_V7a {
public static void main(String[] args) throws IOException {
Path path = Paths.get("balbla.txt");
String text = "Das ist ein zusätzlicher Text\nMit Zeilenvorschub!"; byte[] bytes = text.getBytes("UTF-8");
Files.write(path, bytes, StandardOpenOption.APPEND); }
}
balbla.txt
balbla.txt
Anhängendes Schreiben eines Strings auf eine Datei.
nachher
vorher
java.nio.file.StandardOpenOption
- APPEND - CREATE - …
Siehe API-Dok.
Seite 17
Dateien – Verwendung / Dateioperationen
Dateien erzeugen, kopieren, löschen – Java 7
import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.nio.file.StandardCopyOption;import java.nio.file.StandardOpenOption;
public class CreateCopyDelete {
public static void main(String[] args) throws IOException {
Path path_1 = Paths.get("D:\\users\\hugo\\datei_1.txt"); Path path_2 = Paths.get("D:\\users\\hugo\\datei_2.txt");
// 1. Datei erzeugen Files.createFile(path_1);
// 1. Datei fuellen Files.write(
path_1, "Ein wenig Text.\nAls Inhalt der Datei.\n".getBytes(), StandardOpenOption.WRITE);
// 1. -> 2. Datei kopieren Files.copy(path_1, path_2, StandardCopyOption.REPLACE_EXISTING);
// 1. Datei loeschen Files.delete(path_1); }
}
Seite 18
Dateien – Verwendung / anlysieren
Datei analysieren – nur Java 7 import java.io.File;import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;
import javax.swing.JFileChooser;
public class AnalyseFile {
public static void main(String[] args) throws IOException { File f = null; JFileChooser fc = new JFileChooser(); int chooseResult = fc.showDialog(null, "Bitte Datei auswählen"); if (chooseResult == JFileChooser.APPROVE_OPTION) { f = fc.getSelectedFile(); } if (f != null) {
Path p = f.toPath(); if (Files.isRegularFile(p)) { System.out.println("Die Datei ist " + (Files.isExecutable(p) ? " ausfuehrbar" : " ") + (Files.isReadable(p) ? " lesbar" : " ") + (Files.isWritable(p) ? " schreibbar" : " "));
System.out.println("Der Dateityp ist: " + Files.probeContentType(p)); }
}
}
}
Seite 19
Texte analysieren
Inhalt einer (Text-) Datei analysieren – alle Java-Versionen
Datei-Inhalt = Text = String
Standardverfahren der Textanalyse in Java:
– StringTokenizer, StreamTokenizer veraltet
– Scanner-KlasseText strukturiert lesen (Wort für Wort, Zeile für Zeile, etc.)
– String.split Methode
Text an bestimmten Zeichen aufspalten
– mit den Klassen Pattern und Matcherfür Fortgeschrittene
Seite 20
Texte analysieren – Scanner
Scanner-Klassekann Texte (Strings) in beliebige Einheiten aufspalten und Einheit für Einheit zur Verfügung stellen
verschiedene Arten von Text-Quellen sind dabei möglich.
import java.util.Scanner;
public class Scan {
public static void main(String[] args) { String s = "Dies ist ein Text.\nEr besteht aus\nWorten und Zeilen.\n";
Scanner scanString = new Scanner(s); while (scanString.hasNext()) { System.out.println(scanString.next()); } System.out.println(); ScanString.close();
scanString = new Scanner(s); while (scanString.hasNextLine()) { System.out.println(scanString.nextLine()); } ScanString.close(); }}
DiesisteinText.ErbestehtausWortenundZeilen.
Dies ist ein Text.Er besteht ausWorten und Zeilen.
Wortweise aus einem String lesen
Zeilenweise aus einem String lesen
Scanner stellt diverse next...-Methoden zur Verfügung um den nächsten Text entsprechend einem bestimmten Typ zu analysieren. Siehe API-Doku.
Seite 21
Texte analysieren – Scanner
Scanner-Klassekann Texte (Strings) in beliebige Einheiten aufspalten und Einheit für Einheit zur Verfügung stellen
verschiedene Arten von Text-Quellen sind dabei möglich.
Wortweise aus einer Datei lesen
Zeilenweise aus einer Datei lesen
import java.io.IOException;import java.nio.file.Path;import java.nio.file.Paths;import java.util.Scanner;
public class Scan {
public static void main(String[] args) throws IOException {
Path path = Paths.get("/home/hugo/tmp/blubber1.txt"); Scanner scanFile = new Scanner(path);
while (scanFile.hasNext()) { System.out.println(scanFile.next()); } System.out.println(); scanFile.close();
scanFile = new Scanner(p); while (scanFile.hasNextLine()) { System.out.println(scanFile.nextLine()); } }}
Seite 22
Texte analysieren – String split
Split-Methode der Klasse Stringkann Texte (Strings) in beliebige Einheiten aufspalten und Einheit für Einheit zur Verfügung stellen.
Ähnlich zu Scanner
es können allerdings nur Texte, die in Strings liegen, zerlegt werden
und die Zerlegung erfolgt „in einem Schritt“.
public class Split {
public static void main(String[] args) throws IOException { String s = "Abc die Katze lief im Schnee.";
String[] sParts = s.split("\\s"); System.out.println(Arrays.asList(sParts)); }
}
"Abc die Katze lief im Schnee."
["Abc", "die", "Katze", "lief", "im", "Schnee."]
"\\s": Trenner: jede Folge von „weiße Zeichen“, Leerzeichen, Tabs, etc. (ein regulärer Ausdruck)
Seite 23
Texte analysieren – Reguläre Ausdrücke
Regulärer Ausdruck➢ Ein Textmuster➢ Vielfältige Verwendung bei der Textanalyse (unabhängig von
Programmiersprachen)➢ Wird als Konzept von allen (brauchbaren) anwendungsnahen
Programmiersprachen angeboten➢ Scanner und String.split verwenden reguläre Ausdrücke zur Definition der
Trenner.➢ Reguläre Basis-Ausdrücke in Java, Beispiele:
x jedes Zeichen ist ein Muster das für sich selbst steht
[xy] eine Klasse, ein x oder ein y
regEx1 | regex2 ein Text der zu regEx1 oder regEx2 passt
\\d eine Ziffer (= "[0123456789]" = "[0-9]" )
\\s ein weißes Zeichen
\\w ein Wortzeichen (Buchstabe, Ziffer oder Unterstrich)
. ein einziges beliebiges Zeichen regEx1* ein Text, der zu regEx1 passt, beliebig oft wiederholt \\. ein Punkt, Sonderzeichen wie Punkt brauchen „Escape“-Zeichen
Seite 24
Texte analysieren – Reguläre Ausdrücke
Regulärer AusdruckBeispiel:
public class Match {
public static void main(String[] args) {
String[] strings = {"Abc die Katze lief im Schnee.","Peter schlief im Klee.","Klausi trinkt gerne Tee mit Ruhm.","Die Katze liebt keinen See."};
String[] pattern = {"Katze", ".*ee.*"};
for (String s: strings) { System.out.println(s); for (String word : s.split("\\s")) { for (String pat: pattern) { if (word.matches(pat)) { System.out.println( "\tenthält das Wort " + word + " das zu " + pat + " passt"); } }
} }
}
Abc die Katze lief im Schnee. enthält das Wort Katze das zu Katze passt enthält das Wort Schnee. das zu .*ee.* passtPeter schlief im Klee. enthält das Wort Klee. das zu .*ee.* passtKlausi trinkt gerne Tee mit Ruhm. enthält das Wort Tee das zu .*ee.* passtDie Katze liebt keinen See. enthält das Wort Katze das zu Katze passt enthält das Wort See. das zu .*ee.* passt
Katzeoder etwas mit zwei e-s
Seite 25
Texte analysieren – Beispiel CVS-Datei
CSV-Datei
CSV: Comma Separated Values
Standard-Format für Daten in Textform – ein (wichtiges) Format von sehr vielen
Import- / Export-Format für Excel (und andere Programme)
Tabellen ~ Textdateien
– Zeilen der Tabelle : Zeilen der Textdatei
– Zellen der Tabelle : durch Komma (Semikolon, Tab, …) getrennte Werte in einer Zeile
Seite 26
Texte analysieren – Beispiel CVS-Datei
CSV-Datei einlesen : Datei auswählen an Hand des Content Type
public static Path locateCSVFile(String msg) throws IOException {
JFileChooser fc = new JFileChooser(); File f = null; Path p = null; while (true) { int returnVal = fc.showDialog(null, msg); if (returnVal == JFileChooser.APPROVE_OPTION) { f = fc.getSelectedFile(); p = f.toPath(); if (Files.isRegularFile(p) && Files.isReadable(p) && (Files.probeContentType(p).equals("text/csv") || Files.probeContentType(p).equals("text/comma-separated-values") )) { return p; } JOptionPane.showMessageDialog(null, "Die Datei ist keine CSV Datei!"); } else break; } return null;}
Achtung: Die Erkennung des Datei-Typs ist System-abhängig!Prüfen Sie eventuell welcher Content-Type einer CSV-Datei zugeordnet ist, die mit einem bestimmten Programm (Text-Editor / Excel / Open-Office / ...) auf ihrem System erzeugt wurde.
Seite 27
Texte analysieren – Beispiel CVS-Datei
CSV-Datei einlesen : Datei auswählen an Hand der Datei-Endung
Achtung: In manchen Betriebssystemen kann die Datei-Endung (File Name Extension) versteckt werden.
public static File locateCSVFile(String msg) throws IOException {
JFileChooser fc = new JFileChooser();File f = null;while (true) {
int returnVal = fc.showDialog(null, msg);if (returnVal == JFileChooser.APPROVE_OPTION) {
f = fc.getSelectedFile();if (f.getName().endsWith(".csv")) {
return f;}
JOptionPane.showMessageDialog(null, "Die Datei hat nicht den richtigen Typ");
} else break;} return null;
}
Seite 28
Texte analysieren – Beispiel CVS-Datei
CSV-Datei einlesen : naive Analyse
static List<Map<String, String>> readCSVFile(Path path, String seperator) throws IOException { // erste Zeile / Attribute String[] attributes = null;
// alle Zeilen ausser der ersten List<Map<String, String>> res = new ArrayList<Map<String, String>>();
boolean firstLine = true; // erste Zeile enthaelt Spalten- (=Attribut-) Namen for (String line : Files.readAllLines(path, Charset.defaultCharset())){ if (firstLine) { attributes = line.split(seperator); firstLine = false; continue; } Map<String,String> entry = new HashMap<>(); String[] values = line.split(seperator); int i = 0; for(String a: attributes) { String value = values[i].trim(); entry.put(a, value); i++; if (i == attributes.length || i == values.length) break; } res.add(entry); } return res;} Excel speichert Tabellen in Binärformat. (Unterschiedlich mit den
Versionen wechselnd, teilweise geheim.)Zum Lesen und Schreiben muss man dieses Format genau kennen. Die Java-API enthält keine entsprechenden Klassen. Man kann aber frei verfügbare Open-Source Bibliotheken verwenden, z.B.: Apache POI (http://poi.apache.org/).
Naive Analyse: CSV-Dateien können eine sehr komplexe Struktur ausweisen, vor allem dann, wenn Zellen Werte enthalten, in denen der Trenner vorkommt.
Seite 29
Dateien – Binär-Dateien
Text-Dateien und Binär-Dateien
alle Dateien enthalten Binärdaten!
Textdatei
enthält Bytes deren Bedeutung Zeichen sind
Bedeutung der Bytes als Zeichen wird vom Zeichensatz (Charset) definiert
Eingelesene Bytes müssen in programm-interne Zeichen umgewandelt werden
Zeichen im Programm sind ebenfalls Bytes, aber meist nicht in der gleichen Codierung wie die vom Zeichensatz definierte
Bitmuster A Bitmuster B
Zeichen z
Lesen/Schreiben Umcodieren
Bedeutet nach den Konventionen der Sprache
Bedeutet im Zeichensatz cs
Datei Hauptspeicher / CPU
Zeichensätze sind von großer Bedeutung
Seite 30
Dateien – Binär-Dateien
Text-Dateien und Binär-Dateien
alle Dateien enthalten Binärdaten!
Binärdatei
Enthält Bytes deren Bedeutung von keiner Text-Konvention definiert wird
Die Bedeutung der Bytes wird von der Anwendung definiertEine Umwandlung der Bitmuster beim Lesen und Schreiben
Findet nicht statt: Die Bitmuster werden so gespeichert, wie sie im Hauptspeicher zu finden sind
Findet statt: Die Bitmuster werden beim Lesen decodiert und beim Schreiben codiert.
Seite 31
Dateien – Binär-Dateien
Binär-Dateien / Beispiel: Daten binär einlesen und ausgeben
import java.io.File;import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.nio.charset.Charset;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.StandardOpenOption;
import javax.swing.JFileChooser;import javax.swing.JOptionPane;
public class ByteIO {
public static void main(String[] args) throws IOException { Path pathI = ... Path pathO = ...
InputStream is = Files.newInputStream(pathI, StandardOpenOption.READ); OutputStream os = Files.newOutputStream(pathO, StandardOpenOption.WRITE);
byte[] bytes = new byte[1024]; int size = is.read(bytes); // Bytes einlesen (maximal 1024 Bytes) is.close();
// Bytes entsprechend dem aktuellen Zeichensatz decodieren String s = new String(bytes, 0, size, Charset.defaultCharset()); System.out.println(s);
os.write(bytes, 0, size); // Bytes schreiben os.close(); }
}
Seite 32
Dateien – Binär-Dateien
Binär-Dateien / Serialisierung
alle Dateien enthalten Binärdaten!
Serialisierung / Deserialisierung
Serialisieren: Die Bits von Objekten werden unverändert aus dem Hautspeicher in eine Datei geschrieben.Deserialisieren: Die Bits von Objekten werden unverändert von einer Datei in den Hauptspeicher kopiert Vorteil: SchnellNachteil: Nicht Portabel, das Datenformat an Java gebunden
Speicher
Objekt
1011101001 Datei
Seite 33
Dateien – Binär-Dateien
Binär-Dateien / Beispiel Serialisierung, Deserialisierung
public static void main(String[] args) throws IOException, ClassNotFoundException { Person[] personen_1 = {
new Person("Karl", "Napp"), new Person("Karla", "Kahl")};
Path path = ... ObjectOutputStream os = new ObjectOutputStream(
Files.newOutputStream(path, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING));
os.writeObject(personen_1); os.close();
ObjectInputStream is = new ObjectInputStream( Files.newInputStream(path,
StandardOpenOption.READ)); Person[] personen_2 = (Person[]) is.readObject(); is.close(); for (Person p: personen_2) { System.out.println(p); }}
class Person implements Serializable { private static final long serialVersionUID = 1L; private String name; private String vorName; public Person(String vorName, String name) { this.name = name; this.vorName = vorName; } @Override public String toString() { return "Person["+vorName+" "+name+"]"; }}
Kontrolle der Version der Definition
Das zu speichernde Objekt (ein Array)
Datei öffnen
Objekt speichern
Datei öffnen
Objekt einlesen
Markierung: Serialisieren erlaubt!
Seite 34
Dateien – Binär-Dateien
Binär-Dateien / standardisierte Formate
universelle / standardisierte Formate: z.B.: MP3
anwendungs-spezifische Formate, z.B. Speicherformat von Word, Excel
„lokale“ Formate: Verabredung zwei Partner
Vergleich zu Textdateien
– Vorteil: Speicherung kompakter, schreiben / lesen schneller
– Nachteil: schwer zu entziffern (kann auch ein Vorteil sein)
