Differences

This shows you the differences between two versions of the page.

--- programmierung:eingabe [2024/08/30 14:35] – created swe
+++ programmierung:eingabe [2025/12/20 14:53] (current) – external edit 127.0.0.1
@@ Line 1: / Line 1: @@
-Das Problem, beliebig lange Eingaben mit einem Scanner und einer while-Schleife zu verarbeiten, ist ein klassisches Beispiel für die Verarbeitung von Benutzereingaben in der Programmierung. Hier sind einige allgemeine Überlegungen dazu:
+<!DOCTYPE markdown>
-### Allgemeine Überlegungen
+# Dateien und Datenströme
+## Dateien
+- 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
+---
+## Datenströme
-. **Benutzereingaben verarbeiten**:
+- kontinuierliche Datenflüsse von Quelle zu Ziel oder anders herum
-   - In vielen Anwendungen ist es notwendig, Benutzereingaben zu verarbeiten, sei es für einfache Konsolenanwendungen oder komplexe grafische Benutzeroberflächen.
+- Input / Output
-   - Die Eingaben können variieren, von einfachen Textzeilen bis hin zu komplexen Datenstrukturen.
+- Dateien "fließen" hinaus auf Datenträger und hinein in Arbeitsspeicher
-. **Endlos-Schleifen vermeiden**:
+---
-   - Eine while-Schleife wird oft verwendet, um kontinuierlich Eingaben zu lesen, bis eine bestimmte Bedingung erfüllt ist.
+## Typen von Datenströmen
-   - Es ist wichtig, eine Bedingung zu haben, die die Schleife beendet, um Endlos-Schleifen zu vermeiden, die das Programm zum Absturz bringen könnten.
+### Byte-Streams
+- Folge von Bytes
+- Für Menschen nicht lesbar
+- Arbeiten mit `InputStream` und `OutputStream` und sind für Binärdaten wie Bilder oder Videos geeignet.
+### Text (Binär)-Streams
+- Folge von Zeichen (Unicode)
+- Arbeiten mit `Reader` und `Writer`, speziell für Textdaten in Unicode.
-. **Eingaben validieren**:
+---
-   - Die Validierung der Eingaben ist entscheidend, um sicherzustellen, dass das Programm korrekt funktioniert und keine unerwarteten Fehler auftreten.
-   - Dies kann durch einfache Überprüfungen (z.B. ob die Eingabe leer ist) oder komplexere Validierungen (z.B. ob die Eingabe einem bestimmten Format entspricht) erfolgen.
-. **Ressourcenmanagement**:
+## Java I/O-Grundlagen
-   - Es ist wichtig, Ressourcen wie den Scanner ordnungsgemäß zu verwalten und zu schließen, um Speicherlecks zu vermeiden.
+```java
-   - In Java wird dies durch das Schließen des Scanner-Objekts mit `scanner.close()` erreicht.
+import java.io.*
+```
-### Beispielanwendung
+Die java.io-Bibliothek
+- für Ein- und Ausgabefunktionen verwendet werden
+- Daten lesen/schreiben aus/ in
+  - Dateien
+  - Konsole
+  - Streams
+---
-Stell dir vor, du schreibst ein Programm, das Benutzereingaben liest und diese verarbeitet, bis der Benutzer "exit" eingibt. Dies könnte in einer Vielzahl von Anwendungen nützlich sein, z.B. in einem Chatbot, einem einfachen Texteditor oder einem Kommandozeilen-Tool.
-### Fazit
-Die Verwendung eines Scanners in Kombination mit einer while-Schleife ist eine grundlegende Technik in der Programmierung, die es ermöglicht, flexibel und effizient mit Benutzereingaben umzugehen. Es ist eine wichtige Fähigkeit, die in vielen realen Anwendungen zum Einsatz kommt.
+## Wichtigste Klassen in java.io
+### Byte-Streams
+  - Verschiede InputStreams/ OutputStreams
+  - Arbeiten byteweise
+  - Beispiele: `FileInputStream`, `FileOutputStream`
+---
+```java
+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();
+        }
+    }
+}
+```
+### Text-Streams
+  - 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
+---
+#### FileReader/ FileWriter
+```java
+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();
+        }
+    }
+}
+```
+#### FileReader/ FileWriter
+```java
+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();
+        }
+    }
+}
+```
+---
+#### BufferedReader/ BufferedWriter
+```java
+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();
+        }
+    }
+}
+```
+#### BufferedReader/ BufferedWriter
+```java
+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();
+        }
+    }
+}
+```
+---
+### Wann verwende ich was
+  - `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.
+---
+### Datei neu erstellen vs. Daten an bestehende Datei anhängen
+```java
+...
+    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());
+        }
+    }
+...
+```
+---
+## What about Scanner?
+- Hauptsächliche Verwendung
+- Nicht nur Dateien lesen kann, sondern auch
+- Parsen von Eingaben bietet
+- flexibler, aber oft weniger performant bei großen Datenmengen geht
+---
+### Vergleich: Scanner vs BufferedReader vs FileReader
+| **Kriterium**              | **FileReader**                                 | **BufferedReader**                              | **Scanner**                                      |
+|-----------------------------|-----------------------------------------------|-----------------------------------------------|------------------------------------------------|
+| **Hauptzweck**             | Zeichenweise aus Dateien lesen.               | Effizientes Lesen von Zeichen und Zeilen.      | Lesen und **Parsen** von Eingaben, z. B. Zahlen oder Strings. |
+| **Lesemethoden**           | `read()` (Zeichenweise).                      | `readLine()` (Zeilenweise) oder `read()`.      | Methoden wie `nextInt()`, `nextLine()`, `next()`. |
+| **Performance**            | Langsam für große Dateien.                    | Schnell für große Dateien.                    | Langsamer bei großen Datenmengen (Parsing braucht Zeit). |
+---
+### Wann sollte man welchen verwenden?
+- `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