Wie arbeitet man mit Dateien und Ein- /…

Die Standardbibliothek von Kotlin bietet praktische Erweiterungen für die Arbeit mit I/O, die die Interaktion mit java.io vereinfachen.

Hauptansätze und Klassen:

Datei lesen:
- File.readBytes(): Liest den Inhalt der Datei in ein Byte-Array.
- File.readText(): Liest den Inhalt der Datei als String (unter Berücksichtigung der Kodierung).
- File.forEachLine { ... }: Verarbeitet jede Zeile der Datei.
- File.bufferedReader(): Erstellt einen BufferedReader für zeilenweises Lesen.
- File.inputStream(): Erstellt einen InputStream zum Lesen von Bytes.
In Datei schreiben:
- File.writeBytes(bytes): Schreibt ein Byte-Array in eine Datei.
- File.writeText(text, append): Schreibt einen String in eine Datei. append = true zum Anhängen.
- File.printWriter(): Erstellt einen PrintWriter für formatiertes Schreiben.
- File.outputStream(): Erstellt einen OutputStream zum Schreiben von Bytes.
Arbeiten mit Streams:
- InputStream.bufferedReader(): Wickelt einen InputStream in einen BufferedReader.
- OutputStream.printWriter(): Wickelt einen OutputStream in einen PrintWriter.
- Erweiterungsfunktionen copyTo(outputStream) zum Kopieren von Inhalten zwischen Streams.
Ressourcenverwaltung (Closures):
- Erweiterungsfunktionen use { ... } zum automatischen Schließen von Streams und Lesern/Schreibern, auch bei Ausnahmen.

import java.io.File

fun main() {
    val file = File("my_file.txt")

    // In Datei schreiben
    file.writeText("Hallo, Kotlin I/O!")
    file.appendText("\nFortsetzung der Zeile.")

    // Zeile für Zeile lesen
    file.forEachLine { line ->
        println(line)
    }

    // Gesamten Inhalt als Text lesen
    val content = file.readText()
    println("\nGesamtinhalt der Datei:")
    println(content)

    // BufferedReader mit use verwenden
    file.bufferedReader().use { reader ->
        reader.lines().forEach(::println) // Lesen mit Java Stream API
    }

    // Datei kopieren
    val newFile = File("my_file_copy.txt")
    file.inputStream().use { input ->
        newFile.outputStream().use { output ->
            input.copyTo(output) // Bequemer Kopiervorgang
        }
    }
}

Vergleichstabelle einiger Methoden:

Methode	Zweck	Datentyp	Zeile für Zeile / Ganz	Anmerkung
`readBytes()`	Lesen in Bytes	`ByteArray`	Ganz	Für Binärdaten geeignet
`readText()`	Als Text lesen	`String`	Ganz	Für Textdateien praktisch
`forEachLine { }`	Verarbeitung jeder Zeile	`String`	Zeile für Zeile	Ideal für große Textdateien
`bufferedReader()`	Erstellen eines gepufferten Lesers	N/A	Stream	Flexible Kontrolle, erfordert `use`
`writeBytes()`	Bytes schreiben	`ByteArray`	Ganz	Für Binärdaten geeignet
`writeText()`	Text schreiben	`String`	Ganz/Anhängen	Für Textdateien praktisch
`printWriter()`	Erstellen eines formatierten Schreibers	N/A	Stream	Für formatierten Output nützlich, erfordert `use`

Die Verwendung von use { ... } ist entscheidend für die sichere Arbeit mit I/O in Kotlin, um Ressourcen freizugeben. Kotlin erweitert die bestehenden Java-Klassen (File, InputStream, OutputStream usw.) um nützliche Funktionen.

Wie arbeitet man mit Dateien und Ein- / Ausgabeströmen (I/O) in Kotlin?