0Pricing
Java Academy · Leçon

Utilitaire Files : lire, écrire, copier, déplacer

Utilisez Files.readString, writeString, copy, move et delete pour les opérations courantes sur les fichiers.

Utilitaire Files : lire, écrire, copier, déplacer est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

La classe Files

La classe java.nio.file.Files fournit des méthodes utilitaires statiques pour lire, écrire, copier, déplacer et interroger des fichiers. Elle remplace le code répétitif et verbeux de FileInputStream/FileOutputStream.

import java.nio.file.*;
import java.io.IOException;

Path file = Path.of("example.txt");
// All Files methods throw IOException — handle or propagate

Lire des fichiers

Méthodes modernes pour lire le contenu complet d'un fichier :

Path path = Path.of("notes.txt");

// Read as a single String (Java 11+)
String content = Files.readString(path);
System.out.println(content);

// Read as List of lines
List<String> lines = Files.readAllLines(path);
lines.forEach(System.out::println);

// Read as byte array
byte[] bytes = Files.readAllBytes(path);

Écrire dans des fichiers

Écrivez une chaîne ou une collection de lignes dans un fichier en un seul appel :

Path out = Path.of("output.txt");

// Write a String (overwrites by default)
Files.writeString(out, "Hello, NIO.2!");

// Write with StandardOpenOption.APPEND
Files.writeString(out, "\nAppended line", StandardOpenOption.APPEND);

// Write lines
List<String> lines = List.of("line1", "line2", "line3");
Files.write(out, lines);

Vérifier les propriétés d'un fichier

Interrogez les métadonnées d'un fichier sans l'ouvrir :

Path path = Path.of("data.txt");

System.out.println(Files.exists(path));       // true/false
System.out.println(Files.isRegularFile(path)); // true if not dir
System.out.println(Files.isDirectory(path));   // true if dir
System.out.println(Files.isReadable(path));    // readable?
System.out.println(Files.size(path));          // bytes
System.out.println(Files.getLastModifiedTime(path));

Copier des fichiers

Files.copy(source, target) copie un fichier. Utilisez StandardCopyOption pour contrôler le comportement :

Path src = Path.of("original.txt");
Path dst = Path.of("backup.txt");

// Throws if destination exists (default)
Files.copy(src, dst);

// Overwrite if exists:
Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);

// Copy preserving file timestamps:
Files.copy(src, dst, StandardCopyOption.COPY_ATTRIBUTES);

Déplacer et renommer des fichiers

Files.move() déplace ou renomme un fichier. Un déplacement atomique est possible avec ATOMIC_MOVE :

Path from = Path.of("temp.txt");
Path to   = Path.of("archive/report_2024.txt");

Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);

// Rename in same directory:
Path renamed = from.resolveSibling("new_name.txt");
Files.move(from, renamed, StandardCopyOption.REPLACE_EXISTING);

Supprimer des fichiers

Deux méthodes de suppression : l'une lève une exception si le fichier est introuvable, l'autre non :

Path file = Path.of("temp.txt");

// Throws NoSuchFileException if file doesn't exist:
Files.delete(file);

// Returns false if file didn't exist (no exception):
boolean deleted = Files.deleteIfExists(file);
System.out.println("Deleted: " + deleted);

Créer des répertoires

Créez des répertoires, y compris tous les répertoires intermédiaires :

Path dir = Path.of("output/reports/2024");

// Creates all missing intermediate directories:
Files.createDirectories(dir);

// Creates a single directory (fails if parent missing):
Files.createDirectory(Path.of("output/reports/2025"));

Fichiers et répertoires temporaires

Créez des fichiers temporaires en toute sécurité : la JVM peut les supprimer automatiquement :

// Temp file in default temp directory
Path tmp = Files.createTempFile("prefix_", ".txt");
Files.writeString(tmp, "temp data");
System.out.println(tmp); // something like /tmp/prefix_12345.txt

// Temp directory
Path tmpDir = Files.createTempDirectory("work_");
System.out.println(tmpDir);

Parcourir les lignes avec Files.lines

Files.lines() renvoie un Stream<String> paresseux — il est préférable à readAllLines pour les fichiers volumineux, car tout le contenu n'est pas chargé en mémoire :

try (var stream = Files.lines(Path.of("large.log"))) {
    long errorCount = stream
        .filter(l -> l.contains("ERROR"))
        .count();
    System.out.println("Errors: " + errorCount);
} // stream (and underlying reader) closed automatically

Lire des ressources du classpath

Combinez getClass().getResourceAsStream() avec la copie NIO pour charger des ressources :

try (var in = getClass().getResourceAsStream("/config.json")) {
    Path tmp = Files.createTempFile("config", ".json");
    Files.copy(in, tmp, StandardCopyOption.REPLACE_EXISTING);
    String json = Files.readString(tmp);
    System.out.println(json);
}

Vérification rapide

Quelle méthode devez-vous utiliser pour lire un fichier journal volumineux sans charger simultanément toutes ses lignes en mémoire ?

Récapitulatif : utilitaires Files

Points essentiels :

  • Files.readString/readAllLines/readAllBytes — lire un fichier entier
  • Files.writeString/write — écrire une chaîne ou des lignes
  • Files.copy/move avec StandardCopyOption — copier, renommer ou déplacer
  • Files.delete/deleteIfExists — supprimer en toute sécurité
  • Files.lines — flux paresseux pour les fichiers volumineux (utilisez try-with-resources)

Questions Fréquemment Posées

La leçon « Utilitaire Files : lire, écrire, copier, déplacer » est-elle gratuite ?

Oui — le texte complet de « Utilitaire Files : lire, écrire, copier, déplacer » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Utilitaire Files : lire, écrire, copier, déplacer » ?

Utilisez Files.readString, writeString, copy, move et delete pour les opérations courantes sur les fichiers. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Utilitaire Files : lire, écrire, copier, déplacer » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Path : représenter des emplacements de fichiers
  2. Utilitaire Files : lire, écrire, copier, déplacer
  3. Parcourir les arborescences de répertoires avec Files.walk
  4. WatchService : surveiller les changements de fichiers
← Retour à Java Academy