1. Méthodes pour vérifier l’existence de fichiers et de répertoires
Le travail avec les fichiers ressemble parfois à une promenade dans un champ de mines : on ne sait jamais ce qui vous attend après l’octet suivant. La bonne nouvelle : Java nous donne un « détecteur de métaux » — des méthodes pour vérifier l’existence des fichiers et des dossiers.
Classe File : vérification avec exists(), isFile(), isDirectory()
La méthode classique consiste à utiliser la classe java.io.File :
File file = new File("example.txt");
if (file.exists()) {
System.out.println("Le fichier existe !");
} else {
System.out.println("Fichier introuvable.");
}
La méthode exists() renvoie true si un fichier ou un dossier portant ce nom existe. Mais ce n’est pas tout ! Parfois, il faut savoir ce qui existe exactement : un fichier ou un répertoire.
if (file.isFile()) {
System.out.println("C’est un fichier.");
} else if (file.isDirectory()) {
System.out.println("C’est un répertoire.");
} else {
System.out.println("Rien n’a été trouvé.");
}
Classes Path et Files : approche moderne
Dans les programmes modernes, il est préférable d’utiliser l’API plus récente et plus puissante java.nio.file. Ici, pour vérifier l’existence, on utilise la méthode statique Files.exists() :
import java.nio.file.*;
Path path = Paths.get("example.txt");
if (Files.exists(path)) {
System.out.println("Fichier trouvé via NIO !");
}
Pour vérifier le type de l’objet, utilisez :
if (Files.isRegularFile(path)) {
System.out.println("C’est un fichier régulier !");
}
if (Files.isDirectory(path)) {
System.out.println("C’est un répertoire !");
}
Conseil : pour les nouveaux projets, utilisez directement NIO (Path, Files), car cet API est plus moderne, offre davantage de fonctionnalités et s’intègre bien avec try-with-resources.
Tableau : comparaison des approches
| Approche | Vérification d’existence | Vérification du type (fichier/répertoire) | Modernité |
|---|---|---|---|
|
Oui | Oui (isFile(), isDirectory()) | Ancien |
|
Oui | Oui (isRegularFile(), isDirectory()) | Recommandé |
2. Problème TOCTOU : pourquoi la vérification n’est pas une panacée
En quoi consiste le problème ?
Supposons que vous ayez vérifié : « Le fichier existe ! » — et que vous décidiez aussitôt de le lire. Mais entre ces deux actions, une éternité peut s’écouler à l’échelle du processeur. Pendant ce temps, le fichier peut être supprimé, déplacé, remplacé par un autre processus, ou ses droits d’accès peuvent changer.
C’est comme jeter un coup d’œil dans le réfrigérateur, constater qu’il y a un gâteau, fermer la porte, puis la rouvrir — et découvrir que le gâteau a déjà été mangé. En programmation, il y a aussi ces « colocataires » : d’autres processus, des utilisateurs, des antivirus, le système de fichiers lui-même.
Pourquoi est-ce important ?
En conséquence, même si vous avez vérifié que le fichier existe, au moment de l’ouvrir, une exception peut quand même survenir — par exemple, FileNotFoundException ou AccessDeniedException.
Ainsi, la vérification n’est pas une garantie, seulement une assurance supplémentaire. Soyez toujours prêt à des exceptions et traitez-les !
3. Pratique : vérifier l’existence d’un fichier avant lecture
Ajoutons une fonction qui affiche le contenu d’un fichier s’il existe, et informe l’utilisateur si le fichier n’est pas présent. Montrons deux variantes : via l’ancien et le nouvel API.
Variante 1 : via File
import java.io.*;
public class FileExistenceCheck {
public static void main(String[] args) {
File file = new File("notes.txt");
if (file.exists() && file.isFile()) {
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
System.out.println("Erreur lors de la lecture du fichier : " + e.getMessage());
}
} else {
System.out.println("Le fichier 'notes.txt' est introuvable.");
}
}
}
Variante 2 : via Path et Files
import java.nio.file.*;
import java.io.IOException;
public class PathExistenceCheck {
public static void main(String[] args) {
Path path = Paths.get("notes.txt");
if (Files.exists(path) && Files.isRegularFile(path)) {
try {
Files.lines(path).forEach(System.out::println);
} catch (IOException e) {
System.out.println("Erreur lors de la lecture du fichier : " + e.getMessage());
}
} else {
System.out.println("Le fichier 'notes.txt' est introuvable.");
}
}
}
Même après vérification, on capture les exceptions !
Dans les deux exemples, malgré la vérification préalable, nous utilisons quand même des blocs try–catch, car le fichier peut disparaître ou devenir indisponible à tout moment. C’est la règle d’or du travail avec les fichiers !
4. Vérifier l’existence d’un répertoire
De manière analogue, vous pouvez vérifier l’existence d’un dossier et, en son absence, le créer :
import java.nio.file.*;
public class DirectoryCheck {
public static void main(String[] args) {
Path dir = Paths.get("data");
if (Files.exists(dir) && Files.isDirectory(dir)) {
System.out.println("Le répertoire 'data' a été trouvé.");
} else {
System.out.println("Le répertoire 'data' est introuvable. Création...");
try {
Files.createDirectory(dir);
System.out.println("Répertoire créé !");
} catch (IOException e) {
System.out.println("Erreur lors de la création du répertoire : " + e.getMessage());
}
}
}
}
À propos :
La méthode Files.createDirectory() lève une exception si le dossier existe déjà. Si vous souhaitez créer une arborescence de dossiers (par exemple, "data/2025/09"), utilisez Files.createDirectories(), qui ne lève pas d’erreur si une partie des dossiers existe déjà.
5. Particularités : chemins relatifs et absolus
Chemins relatifs
Lorsque vous écrivez "notes.txt", le programme recherche le fichier dans le « répertoire de travail courant ». Son emplacement dépend de la manière et de l’endroit d’où vous lancez l’application (IDE, terminal, double-clic sur un JAR, etc.).
Chemins absolus
Si vous voulez être sûr de l’emplacement, il vaut mieux utiliser des chemins absolus ou les construire dynamiquement :
String userHome = System.getProperty("user.home");
Path filePath = Paths.get(userHome, "myapp", "notes.txt");
Vérifier le type de l’objet
Parfois, un « fichier » peut se révéler être un répertoire. Vérifiez donc non seulement l’existence, mais aussi le type :
if (Files.isRegularFile(path)) {
// C’est bien un fichier !
}
if (Files.isDirectory(path)) {
// C’est un répertoire !
}
6. Démonstration pratique du problème TOCTOU
Simulons une situation où le fichier disparaît après la vérification mais avant l’ouverture. Exécutez le code et supprimez le fichier manuellement entre la vérification et la lecture :
import java.io.*;
import java.nio.file.*;
public class TOCTOUExample {
public static void main(String[] args) {
Path path = Paths.get("notes.txt");
if (Files.exists(path)) {
System.out.println("Fichier trouvé, lecture imminente...");
// À ce moment, ouvrez l’explorateur et supprimez le fichier "notes.txt" manuellement !
try {
Files.lines(path).forEach(System.out::println);
} catch (IOException e) {
System.out.println("Oups ! Le fichier a disparu : " + e.getMessage());
}
} else {
System.out.println("Fichier introuvable.");
}
}
}
Résultat :
Si vous avez le temps de supprimer le fichier entre la vérification et la lecture, vous obtiendrez une exception. Cela montre clairement que même une vérification soigneuse ne protège pas des modifications imprévues.
7. Erreurs courantes lors de la vérification de l’existence de fichiers et de répertoires
Erreur n° 1 : Se fier uniquement à la vérification sans utiliser try-catch. Si « le fichier est là », on peut le lire tranquillement — pensent les débutants. Mais le fichier peut disparaître ou devenir indisponible, et le programme « plantera ».
Erreur n° 2 : Vérifier uniquement l’existence sans vérifier le type. Si vous ne vérifiez que exists() sans préciser s’il s’agit d’un fichier ou d’un répertoire, vous pouvez tenter d’ouvrir un dossier comme un fichier — et obtenir une erreur.
Erreur n° 3 : Utiliser des chemins relatifs sans comprendre le répertoire de travail. Le programme cherche le fichier « au mauvais endroit », et l’utilisateur ne comprend pas pourquoi rien ne fonctionne.
Erreur n° 4 : Ne pas tenir compte des droits d’accès. Le fichier ou le répertoire peut exister, mais vous n’avez pas les droits de lecture/écriture. Ces erreurs n’apparaissent qu’au moment d’ouvrir le fichier — utilisez toujours try–catch.
Erreur n° 5 : Ignorer la casse du nom de fichier selon l’OS. Sous Windows, les noms de fichiers ne sont pas sensibles à la casse, alors que sous Linux, ils le sont. Le programme peut ne pas trouver "Notes.txt" s’il cherche "notes.txt".
GO TO FULL VERSION