Comment créer un fichier et y écrire en Java

Il existe plusieurs façons de créer un fichier et d'y écrire en Java. Depuis Java 7 et la classe Files, la syntaxe est devenue concise et fiable. Voici les trois approches que vous rencontrerez, de la plus simple à la plus flexible.

Méthode 1 — Files.writeString (la plus simple)

Depuis Java 11, une seule ligne écrit une chaîne entière dans un fichier, en créant le fichier s'il n'existe pas :

import java.nio.file.Files;
import java.nio.file.Path;

Files.writeString(
    Path.of("sortie.txt"),
    "Bonjour le monde !\nDeuxième ligne."
);

Variante pour écrire plusieurs lignes :

import java.util.List;

Files.write(Path.of("notes.txt"), List.of("ligne 1", "ligne 2", "ligne 3"));

L'encodage par défaut est UTF-8. Pour forcer un autre encodage :

import java.nio.charset.StandardCharsets;

Files.writeString(Path.of("fichier.txt"), "contenu", StandardCharsets.ISO_8859_1);

Par défaut, le fichier est écrasé s'il existe. Pour ajouter à la fin (append) :

import java.nio.file.StandardOpenOption;

Files.writeString(
    Path.of("log.txt"),
    "nouvelle ligne\n",
    StandardOpenOption.CREATE,
    StandardOpenOption.APPEND
);

Méthode 2 — BufferedWriter pour des écritures progressives

Quand le contenu est généré en plusieurs étapes, utilisez un BufferedWriter avec try-with-resources :

import java.io.BufferedWriter;
import java.nio.file.Files;
import java.nio.file.Path;

try (BufferedWriter w = Files.newBufferedWriter(Path.of("sortie.txt"))) {
    w.write("Titre\n");
    w.newLine();
    for (int i = 1; i <= 10; i++) {
        w.write("Ligne " + i);
        w.newLine();
    }
}

Le BufferedWriter accumule les caractères en mémoire avant d'écrire par paquets sur le disque — beaucoup plus rapide que des appels write() caractère par caractère.

Méthode 3 — PrintWriter pour du texte formaté

PrintWriter offre println(), printf() et ne lance pas IOException pour les opérations d'écriture (il expose un statut via checkError()) :

import java.io.PrintWriter;

try (PrintWriter p = new PrintWriter(Files.newBufferedWriter(Path.of("rapport.txt")))) {
    p.println("Rapport quotidien");
    p.printf("Total : %,d transactions%n", 1542);
    p.printf("Montant : %.2f €%n", 15342.75);
}

Écrire des bytes bruts

Pour des données binaires, utilisez Files.write avec un byte[] :

byte[] data = { 0x48, 0x65, 0x6C, 0x6C, 0x6F };
Files.write(Path.of("binaire.dat"), data);

Ou un OutputStream pour du streaming :

try (java.io.OutputStream out = Files.newOutputStream(Path.of("image.png"))) {
    out.write(bytesDepuisQuelquePart);
}

Créer un fichier sans y écrire

Si vous voulez simplement créer un fichier vide :

Files.createFile(Path.of("nouveau.txt"));

Lance FileAlreadyExistsException si le fichier existe déjà — utile pour des fichiers de lock ou sentinel.

Créer les dossiers parents si besoin

Path p = Path.of("rapports/2026/04/journal.txt");
Files.createDirectories(p.getParent());
Files.writeString(p, "Contenu");

createDirectories ne lève pas d'exception si les dossiers existent déjà, contrairement à createDirectory.

Gestion des erreurs

Toutes ces méthodes lèvent IOException si le disque est plein, si les permissions sont insuffisantes, si le chemin est invalide :

try {
    Files.writeString(Path.of("/etc/system.conf"), "…");
} catch (java.nio.file.AccessDeniedException e) {
    System.err.println("Permission refusée : " + e.getFile());
} catch (IOException e) {
    System.err.println("Erreur I/O : " + e.getMessage());
}

Les anciennes APIs à éviter

Vous croiserez encore dans du vieux code :

// ❌ Verbeux, pas d'UTF-8 garanti, ressources à fermer manuellement
FileWriter fw = new FileWriter("sortie.txt");
fw.write("contenu");
fw.close();

// ❌ Pas de gestion d'exception claire
new PrintWriter("sortie.txt").write("contenu"); // ressource jamais fermée

Pour tout nouveau code, restez sur l'API java.nio.file.Files + try-with-resources.

Récapitulatif

Cas	Méthode recommandée
Écrire tout d'un coup	Files.writeString
Écrire ligne par ligne	Files.newBufferedWriter + try-with-resources
Texte formaté	PrintWriter via Files.newBufferedWriter
Données binaires	Files.write(path, byte[]) ou newOutputStream
Ajouter à la fin	StandardOpenOption.APPEND
Créer les dossiers manquants	Files.createDirectories

Avec ces cinq ou six patrons, vous couvrez 99 % des cas d'écriture de fichiers en Java — de façon concise, thread-safe et avec une gestion d'erreurs propre.