Zum Hauptinhalt springen

📁 Datei Ein-/Ausgabe

📖 Was ist Datei Ein-/Ausgabe?​

Datei Ein-/Ausgabe (File I/O) bezeichnet das Lesen und Schreiben von Dateien. Es ist essentiell für Datenspeicherung, Konfigurationsverwaltung, Protokollierung und mehr!

💡 Dateien lesen​

Vollständiges Lesen​

import java.io.File

fun main() {
    // Gesamte Datei als String
    val content = File("data.txt").readText()
    println(content)

    // Datei als Liste von Zeilen
    val lines = File("data.txt").readLines()
    for (line in lines) {
        println(line)
    }
}

Sicheres Lesen​

import java.io.File

fun readFileSafe(filename: String): String? {
    return try {
        File(filename).readText()
    } catch (e: Exception) {
        println("Fehler beim Lesen der Datei: ${e.message}")
        null
    }
}

fun main() {
    val content = readFileSafe("data.txt")
    if (content != null) {
        println("Inhalt: $content")
    } else {
        println("Datei kann nicht gelesen werden")
    }
}

Zeilenweise Verarbeitung​

import java.io.File

fun main() {
    // Speichereffizient (gut für große Dateien)
    File("data.txt").forEachLine { line ->
        println(line)
    }

    // useLines - schließt automatisch
    val lineCount = File("data.txt").useLines { lines ->
        lines.count()
    }
    println("Gesamtanzahl Zeilen: $lineCount")
}

✏️ Dateien schreiben​

Überschreiben​

import java.io.File

fun main() {
    // Text schreiben
    File("output.txt").writeText("Hallo\nDas ist Kotlin!")

    // Zeilenweise schreiben
    val lines = listOf("Erste Zeile", "Zweite Zeile", "Dritte Zeile")
    File("output.txt").writeText(lines.joinToString("\n"))
}

Anhängen​

import java.io.File

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

    // Anhängen
    file.appendText("Log 1\n")
    file.appendText("Log 2\n")
    file.appendText("Log 3\n")
}

Sicheres Schreiben​

import java.io.File

fun writeFileSafe(filename: String, content: String): Boolean {
    return try {
        File(filename).writeText(content)
        true
    } catch (e: Exception) {
        println("Fehler beim Schreiben der Datei: ${e.message}")
        false
    }
}

fun main() {
    if (writeFileSafe("data.txt", "Hello Kotlin!")) {
        println("Datei erfolgreich gespeichert")
    }
}

🎯 Praxisbeispiele​

Einfaches Notizbuch​

import java.io.File

class SimpleNotebook(private val filename: String) {
    private val file = File(filename)

    fun write(content: String) {
        file.writeText(content)
        println("Speichern abgeschlossen")
    }

    fun append(content: String) {
        file.appendText("$content\n")
        println("Hinzufügen abgeschlossen")
    }

    fun read(): String {
        return if (file.exists()) {
            file.readText()
        } else {
            "Datei nicht vorhanden"
        }
    }

    fun clear() {
        file.writeText("")
        println("Inhalt gelöscht")
    }
}

fun main() {
    val notebook = SimpleNotebook("mynotes.txt")

    notebook.write("Erste Notiz")
    notebook.append("Zweite Notiz")
    notebook.append("Dritte Notiz")

    println("\n=== Notizeninhalt ===")
    println(notebook.read())
}

Logger​

import java.io.File
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

class Logger(private val filename: String) {
    private val file = File(filename)
    private val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")

    fun log(message: String) {
        val timestamp = LocalDateTime.now().format(formatter)
        file.appendText("[$timestamp] $message\n")
    }

    fun info(message: String) = log("INFO: $message")
    fun error(message: String) = log("ERROR: $message")
    fun warn(message: String) = log("WARN: $message")

    fun readLogs(): String {
        return if (file.exists()) {
            file.readText()
        } else {
            "Keine Logs vorhanden"
        }
    }
}

fun main() {
    val logger = Logger("app.log")

    logger.info("App gestartet")
    logger.warn("Speicher knapp")
    logger.error("Verbindung fehlgeschlagen")

    println(logger.readLogs())
}

CSV-Datei Verarbeitung​

import java.io.File

data class Person(val name: String, val age: Int, val city: String)

object CsvHandler {
    fun writeCsv(filename: String, people: List<Person>) {
        val csv = StringBuilder()
        csv.append("Name,Alter,Stadt\n")

        for (person in people) {
            csv.append("${person.name},${person.age},${person.city}\n")
        }

        File(filename).writeText(csv.toString())
    }

    fun readCsv(filename: String): List<Person> {
        val file = File(filename)
        if (!file.exists()) return emptyList()

        val lines = file.readLines()
        if (lines.isEmpty()) return emptyList()

        return lines.drop(1).map { line ->
            val parts = line.split(",")
            Person(parts[0], parts[1].toInt(), parts[2])
        }
    }
}

fun main() {
    val people = listOf(
        Person("Max Mustermann", 25, "Berlin"),
        Person("Anna Schmidt", 30, "München"),
        Person("Lisa Müller", 28, "Hamburg")
    )

    // CSV speichern
    CsvHandler.writeCsv("people.csv", people)
    println("CSV erfolgreich gespeichert")

    // CSV lesen
    val loaded = CsvHandler.readCsv("people.csv")
    println("\n=== CSV-Inhalt ===")
    loaded.forEach { println(it) }
}

Konfigurationsdatei-Verwaltung​

import java.io.File

class Config(private val filename: String) {
    private val settings = mutableMapOf<String, String>()

    init {
        load()
    }

    private fun load() {
        val file = File(filename)
        if (file.exists()) {
            file.forEachLine { line ->
                val parts = line.split("=")
                if (parts.size == 2) {
                    settings[parts[0].trim()] = parts[1].trim()
                }
            }
        }
    }

    fun save() {
        val content = settings.entries.joinToString("\n") {
            "${it.key}=${it.value}"
        }
        File(filename).writeText(content)
    }

    fun set(key: String, value: String) {
        settings[key] = value
    }

    fun get(key: String): String? {
        return settings[key]
    }

    fun getAll(): Map<String, String> {
        return settings.toMap()
    }
}

fun main() {
    val config = Config("app.config")

    // Konfiguration speichern
    config.set("host", "localhost")
    config.set("port", "8080")
    config.set("timeout", "3000")
    config.save()

    // Konfiguration lesen
    println("Host: ${config.get("host")}")
    println("Port: ${config.get("port")}")

    println("\n=== Gesamte Konfiguration ===")
    config.getAll().forEach { (key, value) ->
        println("$key = $value")
    }
}

📂 Datei-/Verzeichnisverwaltung​

Dateiinformationen​

import java.io.File

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

    println("Existiert: ${file.exists()}")
    println("Datei: ${file.isFile}")
    println("Verzeichnis: ${file.isDirectory}")
    println("Größe: ${file.length()} Bytes")
    println("Absoluter Pfad: ${file.absolutePath}")
    println("Name: ${file.name}")
    println("Übergeordneter Ordner: ${file.parent}")
}

Verzeichnisoperationen​

import java.io.File

fun main() {
    // Verzeichnis erstellen
    val dir = File("mydata")
    dir.mkdir()

    // Dateiliste
    dir.listFiles()?.forEach { file ->
        println("${file.name} (${if (file.isDirectory) "Ordner" else "Datei"})")
    }

    // Untergeordnete Dateien finden
    dir.walk().forEach { file ->
        println(file.absolutePath)
    }
}

Datei kopieren/löschen​

import java.io.File

fun main() {
    val source = File("source.txt")
    val dest = File("dest.txt")

    // Kopieren
    source.copyTo(dest, overwrite = true)

    // Verschieben
    source.renameTo(File("moved.txt"))

    // Löschen
    dest.delete()

    // Gesamtes Verzeichnis löschen
    File("mydata").deleteRecursively()
}

🤔 Häufig gestellte Fragen​

F1. Was passiert, wenn die Datei nicht existiert?​

A: Fehlerbehandlung ist erforderlich!

fun readFileSafe(filename: String): String {
    val file = File(filename)

    if (!file.exists()) {
        return "Datei nicht vorhanden"
    }

    return try {
        file.readText()
    } catch (e: Exception) {
        "Lesefehler: ${e.message}"
    }
}

F2. Was ist mit großen Dateien?​

A: Zeilenweise verarbeiten!

// ❌ Risiko von Speichermangel
val content = File("huge.txt").readText()

// ✅ Zeilenweise Verarbeitung
File("huge.txt").forEachLine { line ->
    processLine(line)
}

F3. Was ist mit Pfadtrennzeichen?​

A: File.separator verwenden!

// ❌ Unterschiedlich je nach OS
val path = "data/files/text.txt"

// ✅ Unabhängig vom OS
val file = File("data", "files").resolve("text.txt")
// oder
val path2 = listOf("data", "files", "text.txt").joinToString(File.separator)

🎬 Zusammenfassung​

Speichern und verwalten Sie Daten mit Datei Ein-/Ausgabe!

Wichtige Punkte:
✅ readText() zum Lesen von Dateien
✅ writeText() zum Schreiben von Dateien
✅ forEachLine() für zeilenweise Verarbeitung
✅ exists() zur Überprüfung der Dateiexistenz
✅ Fehlerbehandlung erforderlich

Nächster Schritt: Erfahren Sie mehr über Pattern Matching in Reguläre Ausdrücke!