¿Cómo trabajar con archivos y flujos de…

En la biblioteca estándar de Kotlin, se proporcionan extensiones convenientes para trabajar con I/O, simplificando la interacción con java.io.

Enfoques y clases principales:

Lectura de archivos:
- File.readBytes(): Lee el contenido del archivo en un array de bytes.
- File.readText(): Lee el contenido del archivo como una cadena (considerando la codificación).
- File.forEachLine { ... }: Procesa cada línea del archivo.
- File.bufferedReader(): Crea un BufferedReader para lectura línea por línea.
- File.inputStream(): Crea un InputStream para leer bytes.
Escritura en archivos:
- File.writeBytes(bytes): Escribe un array de bytes en un archivo.
- File.writeText(text, append): Escribe una cadena en un archivo. append = true para añadir al final.
- File.printWriter(): Crea un PrintWriter para escritura de texto formateado.
- File.outputStream(): Crea un OutputStream para escribir bytes.
Trabajo con flujos:
- InputStream.bufferedReader(): Envuelve un InputStream en un BufferedReader.
- OutputStream.printWriter(): Envuelve un OutputStream en un PrintWriter.
- Funciones de extensión copyTo(outputStream) para copiar contenido entre flujos.
Manejo de recursos (closures):
- Funciones de extensión use { ... } para cerrar automáticamente flujos y lectores/escritores, incluso en caso de excepciones.

import java.io.File

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

    // Escribir en el archivo
    file.writeText("¡Hola, Kotlin I/O!")
    file.appendText("\nContinuación de la línea.")

    // Leer línea por línea
    file.forEachLine { line ->
        println(line)
    }

    // Leer todo el contenido como texto
    val content = file.readText()
    println("\nContenido completo del archivo:")
    println(content)

    // Usar bufferedReader con use
    file.bufferedReader().use { reader ->
        reader.lines().forEach(::println) // Leer usando la API de Streams de Java
    }

    // Copiar archivo
    val newFile = File("my_file_copy.txt")
    file.inputStream().use { input ->
        newFile.outputStream().use { output ->
            input.copyTo(output) // Copia conveniente de flujos
        }
    }
}

Tabla comparativa de algunos métodos:

Método	Propósito	Tipo de datos	Línea por línea / Completo	Nota
`readBytes()`	Leer en bytes	`ByteArray`	Completo	Adecuado para datos binarios
`readText()`	Leer como texto	`String`	Completo	Conveniente para archivos de texto
`forEachLine { }`	Procesar cada línea	`String`	Línea por línea	Ideal para archivos de texto grandes
`bufferedReader()`	Crear un lector bufferizado	N/A	Flujo	Control flexible, requiere `use`
`writeBytes()`	Escribir bytes	`ByteArray`	Completo	Adecuado para datos binarios
`writeText()`	Escribir texto	`String`	Completo/Agregar	Conveniente para archivos de texto
`printWriter()`	Crear un escritor con formato	N/A	Flujo	Útil para salida formateada, requiere `use`

El uso de use { ... } es clave para trabajar de forma segura con I/O en Kotlin, garantizando la liberación de recursos. Kotlin extiende las clases Java existentes (File, InputStream, OutputStream, etc.) con funciones útiles.

¿Cómo trabajar con archivos y flujos de entrada/salida (I/O) en Kotlin?