Vérifier si un fichier ou un répertoire existe en Java

1. Vue d'ensemble

Dans ce rapide tutoriel, nous allons nous familiariser avec différentes manières de vérifier l'existence d'un fichier ou d'un répertoire.

Tout d'abord, nous commencerons par les API NIO modernes, puis nous couvrirons les anciennes approches d'E / S.

2. Utilisation de java.nio.file.Files

Pour vérifier s'il existe un fichier ou un répertoire, nous pouvons tirer parti des Files.exists (chemin) méthode . Comme il ressort clairement de la signature de la méthode, nous devons d'abord obtenir un chemin vers le fichier ou le répertoire prévu. Ensuite, nous pouvons passer ce chemin à la méthode Files.exists (Path) :

Path path = Paths.get("does-not-exist.txt"); assertFalse(Files.exists(path));

Puisque le fichier n'existe pas, il renvoie false . Il convient également de mentionner que si la méthode Files.exists (Path) rencontre une IOException , elle retournera également false .

D'un autre côté, lorsque le fichier donné existe, il retournera vrai comme prévu:

Path tempFile = Files.createTempFile("baeldung", "exist-article"); assertTrue(Files.exists(tempFile));

Ici, nous créons un fichier temporaire puis appelons la méthode Files.exists (Path) .

Cela fonctionne même pour les répertoires :

Path tempDirectory = Files.createTempDirectory("baeldung-exists"); assertTrue(Files.exists(tempDirectory));

Si nous voulons spécifiquement savoir si un fichier ou un répertoire existe, nous pouvons également utiliser les méthodes Files.isDirectory (Path) ou Files.isRegularFile (Path) :

assertTrue(Files.isDirectory(tempDirectory)); assertFalse(Files.isDirectory(tempFile)); assertTrue(Files.isRegularFile(tempFile));

Il existe également une méthode notExists (Path) qui renvoie true si le Path donné n'existe pas:

assertFalse(Files.notExists(tempDirectory));

Parfois, Files.exists (Path) renvoie false car nous ne possédons pas les autorisations de fichier requises . Dans de tels scénarios, nous pouvons utiliser la méthode Files.isReadable (Path) pour nous assurer que le fichier est réellement lisible par l'utilisateur actuel:

assertTrue(Files.isReadable(tempFile)); assertFalse(Files.isReadable(Paths.get("/root/.bashrc")));

2.1. Liens symboliques

Par défaut, la méthode Files.exists (Path) suit les liens symboliques . Si le fichier A a un lien symbolique vers le fichier B , alors la méthode Files.exists (A) renvoie true si et seulement si le fichier B existe déjà:

Path target = Files.createTempFile("baeldung", "target"); Path symbol = Paths.get("test-link-" + ThreadLocalRandom.current().nextInt()); Path symbolicLink = Files.createSymbolicLink(symbol, target); assertTrue(Files.exists(symbolicLink));

Maintenant, si nous supprimons la cible du lien, le Files.exists (Path) retournera false :

Files.deleteIfExists(target); assertFalse(Files.exists(symbolicLink));

Puisque la cible du lien n'existe plus, suivre le lien ne mènera à rien, et Files.exists (Path) retournera false .

Il est même possible de ne pas suivre les liens symboliques en passant un LinkOption approprié comme deuxième argument:

assertTrue(Files.exists(symbolicLink, LinkOption.NOFOLLOW_LINKS));

Étant donné que le lien lui-même existe, la méthode Files.exists (Path) renvoie true. De plus, nous pouvons vérifier si un chemin est un lien symbolique en utilisant la méthode Files.isSymbolicLink (Path) :

assertTrue(Files.isSymbolicLink(symbolicLink)); assertFalse(Files.isSymbolicLink(target));

3. Utilisation de java.io.File

Si nous utilisons Java 7 ou une version plus récente de Java, il est fortement recommandé d'utiliser les API Java NIO modernes pour ce type d'exigences .

Cependant, pour nous assurer qu'un fichier ou un répertoire existe dans le monde IO hérité de Java, nous pouvons appeler la méthode exist () sur les instances File :

assertFalse(new File("invalid").exists());

Si le fichier ou le répertoire existe déjà, il retournera true :

Path tempFilePath = Files.createTempFile("baeldung", "exist-io"); Path tempDirectoryPath = Files.createTempDirectory("baeldung-exists-io"); File tempFile = new File(tempFilePath.toString()); File tempDirectory = new File(tempDirectoryPath.toString()); assertTrue(tempFile.exists()); assertTrue(tempDirectory.exists());

Comme indiqué ci-dessus, la méthode exists () ne se soucie pas si c'est un fichier ou un répertoire. Par conséquent, tant qu'il existe, il retournera vrai .

La méthode isFile () , cependant, retourne true si le chemin donné est un fichier existant:

assertTrue(tempFile.isFile()); assertFalse(tempDirectory.isFile());

De même, la méthode isDirectory () retourne true si le chemin donné est un répertoire existant:

assertTrue(tempDirectory.isDirectory()); assertFalse(tempFile.isDirectory());

Enfin, la méthode canRead () renvoie true si le fichier est lisible:

assertTrue(tempFile.canRead()); assertFalse(new File("/root/.bashrc").canRead());

Lorsqu'il renvoie false , le fichier n'existe pas ou l'utilisateur actuel ne possède pas l'autorisation de lecture sur le fichier.

4. Conclusion

Dans ce court didacticiel, nous avons vu comment nous assurer qu'un fichier ou un répertoire existe en Java. En cours de route, nous avons parlé de NIO moderne et des API IO héritées. Nous avons également vu comment l'API NIO gère les liens symboliques.

Comme d'habitude, tous les exemples sont disponibles sur over sur GitHub.