Travail avec les répertoires : création, suppression, consultation du contenu

1. Création de répertoires

Un répertoire (aussi appelé dossier) n’est pas seulement un conteneur pour des fichiers, c’est la base de l’organisation des données sur le disque. Dans les applications, nous créons en permanence des répertoires pour les données d’entrée/sortie, les journaux, les fichiers temporaires, etc. L’API moderne java.nio.file rend cela pratique et multiplateforme.

Voyons comment créer, supprimer et afficher le contenu des dossiers à l’aide des classes Files, Path et Paths.

Files.createDirectory(path)

Crée un seul répertoire au chemin indiqué. Si le répertoire parent est absent — une exception sera levée.

import java.nio.file.*;

public class DirectoryDemo {
    public static void main(String[] args) throws Exception {
        Path dir = Paths.get("testDir");
        if (!Files.exists(dir)) {
            Files.createDirectory(dir);
            System.out.println("Répertoire créé : " + dir.toAbsolutePath());
        } else {
            System.out.println("Le répertoire existe déjà : " + dir.toAbsolutePath());
        }
    }
}

Si vous tentez de créer un répertoire qui existe déjà, vous obtiendrez FileAlreadyExistsException.

Files.createDirectories(path)

Crée toute la chaîne de répertoires. Si l’un des répertoires intermédiaires est absent — il sera créé automatiquement. Si une partie de la chaîne existe déjà — il n’y aura pas d’erreur.

Path nestedDir = Paths.get("parent/child/grandchild");
Files.createDirectories(nestedDir);
System.out.println("Chaîne de répertoires créée : " + nestedDir.toAbsolutePath());

C’est comme si vous demandiez à Java de construire non seulement la maison, mais aussi l’immeuble et la rue s’ils n’existaient pas encore.

Exemple typique : créer une structure pour un projet

Supposons que vous devez enregistrer des rapports dans le dossier output/reports/2024. N’allez pas vérifier chaque répertoire manuellement — utilisez createDirectories.

Path reportsPath = Paths.get("output/reports/2024");
Files.createDirectories(reportsPath);

Java déterminera elle‑même ce qui existe déjà et ce qu’il faut créer.

2. Suppression de fichiers et de répertoires

Files.delete(path)

Supprime un fichier ou un répertoire vide. Si le répertoire n’est pas vide — DirectoryNotEmptyException sera levée.

Path dir = Paths.get("testDir");
try {
    Files.delete(dir);
    System.out.println("Répertoire supprimé : " + dir.toAbsolutePath());
} catch (DirectoryNotEmptyException e) {
    System.out.println("Impossible de supprimer: le répertoire n'est pas vide!");
}

Files.deleteIfExists(path)

Fonctionne comme delete, mais ne lève pas d’erreur si l’objet n’existe pas. Renvoie true si quelque chose a été supprimé, et false — si l’objet n’existait pas.

Path file = Paths.get("output/reports/2024/report.txt");
if (Files.deleteIfExists(file)) {
    System.out.println("Fichier supprimé.");
} else {
    System.out.println("Fichier introuvable, rien n'a été supprimé.");
}

Comment supprimer un répertoire non vide ?

On ne peut pas supprimer un dossier non vide tel quel. Il faut d’abord supprimer tout son contenu (fichiers et sous‑répertoires), puis le dossier lui‑même. Cela se fait de manière récursive, par exemple via Files.walkFileTree :

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

public class DeleteDirectoryRecursively {
    public static void main(String[] args) throws IOException {
        Path dir = Paths.get("parent");
        if (Files.exists(dir)) {
            Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                    Files.delete(file);
                    return FileVisitResult.CONTINUE;
                }
                @Override
                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                    Files.delete(dir);
                    return FileVisitResult.CONTINUE;
                }
            });
            System.out.println("Le répertoire et tout son contenu ont été supprimés.");
        }
    }
}

Si vous débutez, ne soyez pas intimidé par ce code — nous détaillerons walkFileTree plus tard.

3. Affichage du contenu d’un répertoire

Files.list(path)

Renvoie Stream<Path> — un flux de chemins. Vous pouvez traiter le contenu du dossier via l’API Stream. Chaque entrée — fichier ou sous‑répertoire (sans récursion!).

Path dir = Paths.get("output/reports");
if (Files.exists(dir) && Files.isDirectory(dir)) {
    try (var stream = Files.list(dir)) {
        stream.forEach(path -> System.out.println(path.getFileName()));
    }
}

Détail important : il faut impérativement fermer le flux, donc on utilise try‑with‑resources.

Exemple : afficher les noms des fichiers et des sous‑répertoires

Path reports2024 = Paths.get("output/reports/2024");
try (var stream = Files.list(reports2024)) {
    stream.forEach(path -> {
        String type = Files.isDirectory(path) ? "répertoire" : "fichier";
        System.out.println(path.getFileName() + " — " + type);
    });
}

Obtenir la liste des fichiers sous forme de collection

List<Path> files = Files.list(reports2024)
    .filter(Files::isRegularFile)
    .toList();

System.out.println("Fichiers dans le répertoire :");
files.forEach(System.out::println);

Important : Files.list(path) ne renvoie que le contenu du répertoire courant (niveau supérieur). Pour un parcours récursif, utilisez Files.walk(path).

4. Pratique : mini‑gestionnaire de fichiers

L’utilitaire crée le répertoire mydata/logs, le fichier log1.txt, affiche le contenu du dossier et supprime ensuite le tout.

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

public class MiniFileManager {
    public static void main(String[] args) throws IOException {
        Path logsDir = Paths.get("mydata/logs");
        Files.createDirectories(logsDir);

        Path logFile = logsDir.resolve("log1.txt");
        Files.writeString(logFile, "Salut, journal !");

        System.out.println("Contenu du répertoire " + logsDir + " :");
        try (var stream = Files.list(logsDir)) {
            stream.forEach(path -> System.out.println(" - " + path.getFileName()));
        }

        Files.deleteIfExists(logFile);
        Files.deleteIfExists(logsDir);
        System.out.println("Le fichier et le répertoire ont été supprimés.");
    }
}

Commentaires sur le code :

• Files.createDirectories garantit la création de toute la chaîne.
• resolve — une façon pratique d’ajouter un nom de fichier à un chemin.
• On ferme le flux de Files.list via try‑with‑resources — particulièrement critique sous Windows.

5. Particularités et nuances

Vérification de l’existence

Avant de créer/supprimer, il est utile de vérifier si le chemin existe :

if (!Files.exists(path)) {
    Files.createDirectory(path);
}

Droits d’accès

Si le programme n’a pas les droits de création/suppression — vous obtiendrez AccessDeniedException. Par exemple, créer un dossier à la racine du disque avec un utilisateur standard échouera presque toujours.

Répertoire vide ou non vide

On ne peut supprimer qu’un répertoire vide (Files.delete). Pour supprimer avec tout son contenu, utilisez un parcours récursif (walkFileTree).

Multiplateforme

L’API java.nio.file fonctionne correctement sur tous les systèmes d’exploitation populaires et tient compte des séparateurs de chemin. Pour construire des chemins, utilisez Paths.get et Path.resolve, et non des concaténations de chaînes.

Liens symboliques

Pour les tâches de base, vous pouvez ne pas vous en soucier, mais si vous rencontrez des entrées « inhabituelles » qui ne sont ni un fichier ordinaire ni un répertoire — il s’agit peut‑être de liens symboliques. Nous y reviendrons dans des cours avancés.

6. Erreurs courantes lors de la manipulation des répertoires

Erreur n° 1 : tentative de suppression d’un répertoire non vide par un simple appel à Files.delete(path). Java lèvera DirectoryNotEmptyException. Supprimez d’abord le contenu, puis le dossier lui‑même.

Erreur n° 2 : oubli de fermer le flux renvoyé par Files.list(). Sans try‑with‑resources, le flux restera ouvert et, sous Windows, une erreur pourra survenir lors de la suppression du répertoire.

Erreur n° 3 : création d’un répertoire sans vérifier l’existence du parent. Appeler Files.createDirectory pour un chemin du type parent/child, lorsque parent n’existe pas, entraînera NoSuchFileException. Utilisez Files.createDirectories.

Erreur n° 4 : utilisation de chemins absolus sans nécessité. Préférez les chemins relatifs dans le projet — votre code sera plus portable.

Erreur n° 5 : IOException non gérée. Toute opération avec le système de fichiers peut échouer. Enveloppez dans un try-catch ou propagez l’exception.

Erreur n° 6 : tentative de créer/supprimer dans un dossier pour lequel vous n’avez pas les droits. Dans ce cas, vous obtiendrez AccessDeniedException. Vérifiez le contexte d’exécution et les droits d’accès.