Comment travailler avec les fichiers et les flux…

La bibliothèque standard de Kotlin fournit des extensions pratiques pour travailler avec l'I/O, simplifiant l'interaction avec java.io.

Approches principales et classes:

Lecture de fichiers:
- File.readBytes(): Lit le contenu du fichier dans un tableau de bytes.
- File.readText(): Lit le contenu du fichier en tant que chaîne (en tenant compte du codage).
- File.forEachLine { ... }: Traite chaque ligne du fichier.
- File.bufferedReader(): Crée un BufferedReader pour la lecture ligne par ligne.
- File.inputStream(): Crée un InputStream pour lire des bytes.
Écriture dans un fichier:
- File.writeBytes(bytes): Écrit un tableau de bytes dans un fichier.
- File.writeText(text, append): Écrit une chaîne dans un fichier. append = true pour ajouter à la fin.
- File.printWriter(): Crée un PrintWriter pour l'écriture de texte formaté.
- File.outputStream(): Crée un OutputStream pour écrire des bytes.
Travail avec les flux:
- InputStream.bufferedReader(): Enveloppe un InputStream dans un BufferedReader.
- OutputStream.printWriter(): Enveloppe un OutputStream dans un PrintWriter.
- Fonctions d'extension copyTo(outputStream) pour copier le contenu entre flux.
Gestion des ressources (closures):
- Fonctions d'extension use { ... } pour fermer automatiquement les flux et lecteurs/écrivains, même en cas d'exception.

import java.io.File

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

    // Écrire dans le fichier
    file.writeText("Bonjour, Kotlin I/O!")
    file.appendText("\nSuite de la ligne.")

    // Lire ligne par ligne
    file.forEachLine { line ->
        println(line)
    }

    // Lire tout le contenu comme texte
    val content = file.readText()
    println("\nContenu complet du fichier:")
    println(content)

    // Utiliser bufferedReader avec use
    file.bufferedReader().use { reader ->
        reader.lines().forEach(::println) // Lecture via l'API Stream de Java
    }

    // Copier le fichier
    val newFile = File("my_file_copy.txt")
    file.inputStream().use { input ->
        newFile.outputStream().use { output ->
            input.copyTo(output) // Copie pratique des flux
        }
    }
}

Tableau comparatif de quelques méthodes:

Méthode	But	Type de données	Ligne par ligne / Tout	Remarque
`readBytes()`	Lecture en bytes	`ByteArray`	Tout	Convient pour données binaires
`readText()`	Lecture en texte	`String`	Tout	Pratique pour fichiers texte
`forEachLine { }`	Traitement de chaque ligne	`String`	Ligne par ligne	Idéal pour grands fichiers texte
`bufferedReader()`	Création d'un lecteur bufferisé	N/A	Flux	Contrôle flexible, nécessite `use`
`writeBytes()`	Écrire des bytes	`ByteArray`	Tout	Convient pour données binaires
`writeText()`	Écrire du texte	`String`	Tout/ajout	Pratique pour fichiers texte
`printWriter()`	Création d'un écrivain formaté	N/A	Flux	Utile pour sortie formatée, nécessite `use`

L'utilisation de use { ... } est essentielle pour travailler en toute sécurité avec l'I/O en Kotlin, garantissant la libération des ressources. Kotlin étend les classes Java existantes (File, InputStream, OutputStream, etc.) avec des fonctions utiles.

Comment travailler avec les fichiers et les flux d'entrée/sortie (I/O) en Kotlin?