Como trabalhar com ficheiros e fluxos de…

A biblioteca padrão do Kotlin fornece extensões convenientes para trabalhar com I/O, simplificando a interação com java.io.

Abordagens principais e classes:

Leitura de ficheiros:
- File.readBytes(): Lê o conteúdo do ficheiro para um array de bytes.
- File.readText(): Lê o conteúdo do ficheiro como uma string (considerando a codificação).
- File.forEachLine { ... }: Processa cada linha do ficheiro.
- File.bufferedReader(): Cria um BufferedReader para leitura linha por linha.
- File.inputStream(): Cria um InputStream para ler bytes.
Escrita em ficheiros:
- File.writeBytes(bytes): Escreve um array de bytes num ficheiro.
- File.writeText(text, append): Escreve uma string num ficheiro. append = true para acrescentar ao final.
- File.printWriter(): Cria um PrintWriter para escrita de texto formatado.
- File.outputStream(): Cria um OutputStream para escrever bytes.
Trabalho com fluxos:
- InputStream.bufferedReader(): Envolve um InputStream num BufferedReader.
- OutputStream.printWriter(): Envolve um OutputStream num PrintWriter.
- Funções de extensão copyTo(outputStream) para copiar conteúdo entre fluxos.
Gestão de recursos (closures):
- Funções de extensão use { ... } para fechar automaticamente fluxos e leitores/escritores, mesmo em caso de exceções.

import java.io.File

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

    // Escrever no ficheiro
    file.writeText("Olá, Kotlin I/O!")
    file.appendText("\nContinuação da linha.")

    // Ler linha por linha
    file.forEachLine { line ->
        println(line)
    }

    // Ler todo o conteúdo como texto
    val content = file.readText()
    println("\nConteúdo completo do ficheiro:")
    println(content)

    // Usar bufferedReader com use
    file.bufferedReader().use { reader ->
        reader.lines().forEach(::println) // Leitura via API de Streams do Java
    }

    // Copiar ficheiro
    val newFile = File("my_file_copy.txt")
    file.inputStream().use { input ->
        newFile.outputStream().use { output ->
            input.copyTo(output) // Cópia conveniente de fluxos
        }
    }
}

Tabela comparativa de alguns métodos:

Método	Propósito	Tipo de dados	Linha por linha / Completo	Nota
`readBytes()`	Leitura em bytes	`ByteArray`	Completo	Adequado para dados binários
`readText()`	Leitura como texto	`String`	Completo	Conveniente para ficheiros de texto
`forEachLine { }`	Processar cada linha	`String`	Linha por linha	Ideal para grandes ficheiros de texto
`bufferedReader()`	Criar um leitor bufferizado	N/A	Fluxo	Controlo flexível, requer `use`
`writeBytes()`	Escrever bytes	`ByteArray`	Completo	Adequado para dados binários
`writeText()`	Escrever texto	`String`	Completo/Adicionar	Conveniente para ficheiros de texto
`printWriter()`	Criar um escritor formatado	N/A	Fluxo	Útil para saída formatada, requer `use`

O uso de use { ... } é fundamental para trabalhar com segurança com I/O em Kotlin, garantindo a libertação de recursos. Kotlin estende as classes Java existentes (File, InputStream, OutputStream, etc.) com funções úteis.

Como trabalhar com ficheiros e fluxos de entrada/saída (I/O) em Kotlin?