1. Création de fichiers
On doit souvent créer des fichiers par programme : pour les journaux (logs), les données temporaires, l’export de rapports, l’import de données, l’enregistrement de paramètres et bien d’autres choses. En Java, pour cela, comme vous vous en doutez probablement, il vaut mieux utiliser l’API moderne — java.nio.file.
Outil principal : Files.createFile(Path)
Cette méthode crée un nouveau fichier au chemin indiqué. Si le fichier existe déjà, une exception est levée.
Exemple : créer un fichier texte dans le répertoire courant
import java.nio.file.*;
public class CreateFileExample {
public static void main(String[] args) {
Path path = Path.of("hello.txt");
try {
Files.createFile(path);
System.out.println("Fichier créé : " + path.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("Le fichier existe déjà : " + path);
} catch (Exception e) {
System.out.println("Erreur lors de la création du fichier : " + e.getMessage());
}
}
}
À noter :
Files.createFile lève FileAlreadyExistsException si le fichier existe déjà. C’est pourquoi on vérifie souvent son existence avant de le créer.
Vérifier l’existence d’un fichier
Path path = Path.of("hello.txt");
if (!Files.exists(path)) {
Files.createFile(path);
}
Conseil :
La vérification de l’existence d’un fichier n’est pas une protection contre les courses entre threads, mais pour la plupart des scénarios utilisateurs, c’est une approche tout à fait valable.
En bref : que se passe-t-il lors de la création d’un fichier ?
- Si le fichier n’existe pas et que le chemin est valide — un nouveau fichier vide est créé.
- Si le fichier existe déjà — une exception est levée.
- Si le chemin est incorrect, si les droits manquent ou si le dossier n’existe pas — une autre exception sera levée (IOException, NoSuchFileException, etc.).
2. Création de dossiers
Différence entre Files.createDirectory et Files.createDirectories
- Files.createDirectory(Path) — crée un seul dossier. Si le dossier parent n’existe pas — erreur.
- Files.createDirectories(Path) — crée toute la chaîne des dossiers manquants (comme un magicien qui construit l’escalier sous vos pieds).
Exemple : créer un dossier
Path dir = Path.of("data");
try {
Files.createDirectory(dir);
System.out.println("Dossier créé : " + dir.toAbsolutePath());
} catch (FileAlreadyExistsException e) {
System.out.println("Le dossier existe déjà : " + dir);
} catch (Exception e) {
System.out.println("Erreur lors de la création du dossier : " + e.getMessage());
}
Exemple : créer une structure de dossiers imbriqués
Path nested = Path.of("data/reports/2024");
try {
Files.createDirectories(nested);
System.out.println("Structure de dossiers créée : " + nested.toAbsolutePath());
} catch (Exception e) {
System.out.println("Erreur lors de la création de la structure : " + e.getMessage());
}
À noter : si certains dossiers existent déjà, createDirectories ne s’en inquiète pas — il crée simplement ceux qui manquent. Si vous utilisez createDirectory pour un dossier imbriqué alors que le parent n’existe pas encore — ce sera une erreur.
Tableau : comparaison des méthodes de création de dossiers
| Méthode | Crée un seul dossier | Crée des dossiers imbriqués | N’échoue pas si certains existent déjà |
|---|---|---|---|
|
✔ | ✗ | ✗ |
|
✔ | ✔ | ✔ |
3. Suppression de fichiers
Supprimer des fichiers, c’est un peu comme sortir les poubelles : l’essentiel est de ne pas jeter quelque chose d’important ! En Java, il existe deux méthodes principales pour cela :
- Files.delete(Path) — supprime un fichier ou un dossier vide. S’il n’existe pas — une exception est levée.
- Files.deleteIfExists(Path) — supprime le fichier, mais s’il n’existait pas — ne fait rien.
Exemple : supprimer un fichier temporaire
Path tempFile = Path.of("temp.txt");
try {
Files.delete(tempFile);
System.out.println("Fichier supprimé : " + tempFile);
} catch (NoSuchFileException e) {
System.out.println("Fichier introuvable : " + tempFile);
} catch (DirectoryNotEmptyException e) {
System.out.println("Le dossier n’est pas vide : " + tempFile);
} catch (Exception e) {
System.out.println("Erreur lors de la suppression : " + e.getMessage());
}
Option plus sûre
boolean deleted = Files.deleteIfExists(tempFile);
if (deleted) {
System.out.println("Le fichier a été supprimé.");
} else {
System.out.println("Fichier introuvable — rien à supprimer.");
}
Important !
- Si le fichier est ouvert dans un autre programme — une exception peut être levée (par exemple sous Windows).
- Si vous essayez de supprimer un dossier non vide — vous obtiendrez l’erreur DirectoryNotEmptyException.
4. Suppression de dossiers
On supprime les dossiers en Java à peu près comme les fichiers, avec une nuance : les méthodes standard ne suppriment que les dossiers vides.
Exemple : supprimer un dossier vide
Path emptyDir = Path.of("empty_folder");
try {
Files.delete(emptyDir);
System.out.println("Dossier supprimé : " + emptyDir);
} catch (DirectoryNotEmptyException e) {
System.out.println("Le dossier n’est pas vide : " + emptyDir);
} catch (NoSuchFileException e) {
System.out.println("Dossier introuvable : " + emptyDir);
} catch (Exception e) {
System.out.println("Erreur lors de la suppression du dossier : " + e.getMessage());
}
Que faire des dossiers non vides ?
Pour supprimer des dossiers non vides, il faut supprimer récursivement tous les fichiers et sous-dossiers. C’est un sujet pour un cours à part (et une petite aventure), mais si vous êtes pressé, voici le code, étudiez-le et essayez de le reproduire :
import java.nio.file.*;
import java.io.IOException;
public class DeleteDirectoryRecursively {
public static void deleteRecursively(Path path) throws IOException {
if (Files.isDirectory(path)) {
try (var entries = Files.list(path)) {
for (Path entry : entries.toList()) {
deleteRecursively(entry);
}
}
}
Files.delete(path);
}
}
Attention :
Ce code supprimera tout ce qui se trouve dans le dossier ! Utilisez-le avec prudence.
5. Conseils pratiques
Vérifier l’existence avant la suppression
if (Files.exists(path)) {
Files.delete(path);
} else {
System.out.println("Le fichier/le dossier n’existe pas.");
}
Mais si vous utilisez deleteIfExists, ce n’est pas nécessaire.
Gestion des exceptions
En manipulant des fichiers, on rencontre souvent des imprévus. Java lève pour cela différentes exceptions :
- NoSuchFileException — fichier ou dossier introuvable. Par exemple, vous essayez d’ouvrir quelque chose qui a déjà été supprimé.
- DirectoryNotEmptyException — vous voulez supprimer un dossier alors qu’il contient encore quelque chose.
- IOException — avertissement générique : quelque chose s’est mal passé. La cause peut varier — droits insuffisants, fichier utilisé par un autre programme, chemin incorrect.
Schéma visuel : méthodes principales
+-------------------+ +--------------------+
| Files.createFile | ----> | Nouveau fichier |
+-------------------+ +--------------------+
+---------------------+ +--------------------+
| Files.createDirectory|----> | Nouveau dossier |
+---------------------+ +--------------------+
+-------------------+ +--------------------+
| Files.delete | ----> | Fichier/dossier |
+-------------------+ | supprimé |
+--------------------+
(mais seulement si le dossier est vide !)
6. Erreurs courantes lors de la création et de la suppression de fichiers et de dossiers
Erreur n°1 : vous tentez de créer un fichier/dossier qui existe déjà. Les méthodes Files.createFile et Files.createDirectory lèvent une exception si l’objet existe déjà. Solution — vérifier l’existence au préalable ou intercepter l’exception.
Erreur n°2 : vous essayez de créer un dossier imbriqué via createDirectory alors que le parent n’existe pas encore. Dans ce cas, vous obtiendrez NoSuchFileException. Utilisez createDirectories pour créer la chaîne de dossiers.
Erreur n°3 : vous essayez de supprimer un dossier non vide via Files.delete. Vous obtiendrez DirectoryNotEmptyException. Pour supprimer des dossiers non vides, il faut procéder de manière récursive.
Erreur n°4 : droits insuffisants pour créer/supprimer dans le dossier indiqué. Une AccessDeniedException ou une IOException sera levée. Exécutez le programme avec les droits nécessaires ou utilisez des dossiers accessibles.
Erreur n°5 : fichier utilisé par un autre processus. Sous Windows (et parfois sous d’autres OS), on ne peut pas supprimer un fichier s’il est ouvert dans un autre programme. Vous obtiendrez une IOException. Fermez toutes les applications qui utilisent le fichier avant la suppression.
Erreur n°6 : utilisation de chemins relatifs sans savoir « où vous vous trouvez ». Le fichier est créé ailleurs que prévu. Pour être sûr, utilisez toAbsolutePath() et affichez le chemin.
GO TO FULL VERSION