• Speicherstrukturen für Daten
• Herkunft des Wortes file
  • aus dem Altfranzösischen Wort “fil”, das “Faden” oder “Draht” bedeutete.
  • Im Mittelalter wurden Dokumente oft an einem Faden oder Draht befestigt, um sie zusammenzuhalten.
  • So entstand die Bedeutung des Wortes “file” als “Sammlung von Dokumenten”.
• Im Deutschen: Datei = Daten + Kartei

• kontinuierliche Datenflüsse von Quelle zu Ziel oder anders herum
• Input / Output
• Dateien “fließen” hinaus auf Datenträger und hinein in Arbeitsspeicher

• Folge von Bytes
• Für Menschen nicht lesbar
• Arbeiten mit InputStream und OutputStream und sind für Binärdaten wie Bilder oder Videos geeignet.

• Folge von Zeichen (Unicode)
• Arbeiten mit Reader und Writer, speziell für Textdaten in Unicode.

import java.io.*

• für Ein- und Ausgabefunktionen verwendet werden
• Daten lesen/schreiben aus/ in
  • Dateien
  • Konsole
  • Streams

• Verschiede InputStreams/ OutputStreams
• Arbeiten byteweise
• Beispiele: FileInputStream, FileOutputStream

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class StreamExample {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("binary.dat")) {
            fos.write(new byte[]{65, 66, 67}); // A, B, C
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try (FileInputStream fis = new FileInputStream("binary.dat")) {
            int b;
            while ((b = fis.read()) != -1) {
                System.out.print((char) b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• Verschiedene Reader/Writer
• Arbeiten mit Zeichen und unterstützen Encoding wie UTF-8 oder UTF-16
• FileReader/ FileWriter
• Lesen und Schreiben von Textdateien
  • Zeichen für Zeichen
• BufferedReader/ BufferedWriter
  • Puffern Daten
  • Effizientere Verarbeitung von Textdateien

import java.io.FileReader;
import java.io.IOException;
 
public class FileReaderExample {
    public static void main(String[] args) {
        try (FileReader reader = new FileReader("example.txt")) {
            int ch;
            while ((ch = reader.read()) != -1) { // Zeichenweise lesen
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;
 
public class FileReaderWriterExample {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("example.txt")) {
            writer.write("Hallo, Java IO!");
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try (FileReader reader = new FileReader("example.txt")) {
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) { // Zeilenweise lesen
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;
 
public class BufferedReaderWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
            writer.write("Effizientes Schreiben mit BufferedWriter!");
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

• FileReader
  • kleinere Dateien
  • Bei Notwendigkeit von zeichenweisem Einlesen
• BufferedReader
  • effizientes Lesen von Textdaten.
• Best Practices:
  • try-with-resources: Automatisches Schließen von Streams, um Ressourcenlecks zu vermeiden.
  • Fehlerbehandlung: Abfangen von IOException für robusteren Code.

...
    public static void main(String[] args) {
        String filePath = "example.txt";
 
        // Schreiben in die Datei (überschreibt den bestehenden Inhalt)
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            writer.write("Dies ist der erste Text in der Datei.");
            writer.newLine(); // Neue Zeile einfügen
            writer.write("Noch eine Zeile wird hinzugefügt.");
            System.out.println("Text erfolgreich geschrieben.");
        } catch (IOException e) {
            System.out.println("Fehler beim Schreiben in die Datei: " + e.getMessage());
        }
 
        // Anhängen an die Datei
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) {
            writer.newLine(); // Neue Zeile am Ende der Datei
            writer.write("Dies ist ein angehängter Text.");
            writer.newLine(); // Neue Zeile einfügen
            writer.write("Noch ein angehängter Text.");
            System.out.println("Text erfolgreich angehängt.");
        } catch (IOException e) {
            System.out.println("Fehler beim Anhängen an die Datei: " + e.getMessage());
        }
    }
...

• Hauptsächliche Verwendung
• Nicht nur Dateien lesen kann, sondern auch
• Parsen von Eingaben bietet
• flexibler, aber oft weniger performant bei großen Datenmengen geht

• Scanner
  • Parsing
  • Anwendungen, bei denen unterschiedliche Datentypen aus der Eingabe verarbeitet werden sollen.
• BufferedReader
  • schneller
  • Zeilenweise Textverarbeitung
  • ohne Dateninterpretation
• FileReader
  • einfachste Variante
  • wird wegen fehlender Effizienz und Flexibilität seltener verwendet