Comment vérifier si un fichier existe en Java?

Comment puis-je vérifier si un fichier existe, avant de l’ouvrir pour lire en Java? (équivalent de Perl’s -e $filename ).

La seule question similaire sur SO concerne l’écriture du fichier et a donc reçu une réponse à l’aide de FileWriter qui n’est évidemment pas applicable ici.

Si possible, je préférerais un véritable appel API retournant true / false plutôt que certains “Appel API pour ouvrir un fichier et intercepter quand il lève une exception que vous vérifiez” pas de fichier “dans le texte”, mais je peux vivre avec le dernier.

En utilisant java.io.File :

 File f = new File(filePathSsortingng); if(f.exists() && !f.isDirectory()) { // do something } 

Je recommande d’utiliser isFile() au lieu de isFile() exists() . La plupart du temps, vous cherchez à vérifier si le chemin d’access pointe vers un fichier et non seulement qu’il existe. Rappelez-vous que exists() renverra true si votre chemin pointe vers un répertoire.

 new File("path/to/file.txt").isFile(); 

new File("C:/").exists() renverra true mais ne vous permettra pas de l’ouvrir et de le lire en tant que fichier.

En utilisant nio dans Java SE 7,

 import java.nio.file.*; Path path = Paths.get(filePathSsortingng); if (Files.exists(path)) { // file exist } if (Files.notExists(path)) { // file is not exist } 

Si les deux existent et que notExists renvoie false, l’existence du fichier ne peut pas être vérifiée. (peut-être pas de droit d’access à ce chemin)

Vous pouvez vérifier si le chemin est un répertoire ou un fichier normal.

 if (Files.isDirectory(path)) { // path is directory } if (Files.isRegularFile(path)) { // path is regular file } 

Veuillez vérifier ce tutoriel Java SE 7 .

En utilisant Java 8:

 if(Files.exists(Paths.get(filePathSsortingng))) { // do something } 
 File f = new File(filePathSsortingng); 

Cela ne créera pas de fichier physique. Va simplement créer un object de la classe File. Pour créer physiquement un fichier, vous devez le créer explicitement:

 f.createNewFile(); 

Ainsi, f.exists() peut être utilisé pour vérifier si un tel fichier existe ou non.

 f.isFile() && f.canRead() 

Le premier hit pour “fichier java existe” sur google:

 import java.io.*; public class FileTest { public static void main(Ssortingng args[]) { File f = new File(args[0]); System.out.println(f + (f.exists()? " is found " : " is missing ")); } } 

Vous pouvez utiliser les éléments suivants: File.exists()

Ne pas FileNotFoundException. simplement l’ FileNotFoundException. Le système de fichiers doit tester si le fichier existe de toute façon. Il est inutile de faire tout cela deux fois, et plusieurs raisons de ne pas le faire, telles que:

  • doubler le code
  • le problème de la fenêtre temporelle dans lequel le fichier peut exister lorsque vous testez, mais pas lorsque vous ouvrez, ou vice versa, et
  • le fait que, comme le montre l’existence de cette question, vous pourriez faire le mauvais test et obtenir la mauvaise réponse.

N’essayez pas de deviner le système. Il sait Et n’essayez pas de prédire l’avenir. En général, la meilleure façon de vérifier si une ressource est disponible est d’essayer de l’utiliser.

Il y a plusieurs façons d’y parvenir.

  1. En cas de juste pour l’existence. Ce pourrait être un fichier ou un répertoire.

     new File("/path/to/file").exists(); 
  2. Vérifier le fichier

     File f = new File("/path/to/file"); if(f.exists() && f.isFile()) {} 
  3. Vérifiez le répertoire.

     File f = new File("/path/to/file"); if(f.exists() && f.isDirectory()) {} 
  4. Java 7 façon.

     Path path = Paths.get("/path/to/file"); Files.exists(path) // Existence Files.isDirectory(path) // is Directory Files.isRegularFile(path) // Regular file Files.isSymbolicLink(path) // Symbolic Link 

Pour moi, la combinaison de la réponse acceptée par Sean AO Harney et du commentaire résultant de Cort3z semble être la meilleure solution.

Utilisé l’extrait suivant:

 File f = new File(filePathSsortingng); if(f.exists() && f.isFile()) { //do something ... } 

J’espère que cela pourrait aider quelqu’un.

Cela vaut également la peine de se familiariser avec Commons FileUtils http://commons.apache.org/io/api-release/org/apache/commons/io/FileUtils.html Cela a des méthodes supplémentaires pour gérer les fichiers et souvent mieux que JDK.

Je sais que je suis un peu en retard dans ce fil. Cependant, voici ma réponse, valide depuis Java 7 et plus.

L’extrait suivant

 if(Files.isRegularFile(Paths.get(pathToFile))) { // do something } 

est parfaitement satisfaisant, car la méthode isRegularFile renvoie false si le fichier n’existe pas. Par conséquent, pas besoin de vérifier si Files.exists(...) .

Notez que les autres parameters sont des options indiquant comment gérer les liens. Par défaut, les liens symboliques sont suivis.

De la documentation Java Oracle

Si vous voulez rechercher un File dans un répertoire

 Ssortingng directoryPath = dir.getAbsolutePath() boolean check = new File(new File(directoryPath), aFile.getName()).exists(); 

et vérifier le résultat de la check

 new File("/path/to/file").exists(); 

fera le tour

N’utilisez pas le constructeur de fichiers avec Ssortingng.
Cela peut ne pas fonctionner!
Au lieu d’utiliser cette adresse URI:

 File f = new File(new URI("file:///"+filePathSsortingng.replace('\\', '/'))); if(f.exists() && !f.isDirectory()) { // to do } 

File.exists() pour vérifier si un fichier existe, il retournera une valeur booléenne pour indiquer le statut de l’opération de vérification; true si le fichier existe faux s’il n’existe pas.

 File f = new File("c:\\test.txt"); if(f.exists()){ System.out.println("File existed"); }else{ System.out.println("File not found!"); } 

Par exemple, si vous avez un répertoire de fichiers et que vous souhaitez vérifier s’il existe

 File tmpDir = new File("/var/tmp"); boolean exists = tmpDir.exists(); 

exists retournera faux si le fichier n’existe pas

source: https://alvinalexander.com/java/java-file-exists-directory-exists

Vous pouvez utiliser le code suivant pour vérifier:

 import java.io.File; class Test{ public static void main(Ssortingng[] args){ File f = new File(args[0]); //file name will be entered by user at runtime System.out.println(f.exists()); //will print "true" if the file name given by user exists, false otherwise if(f.exists()) { //executable code; } } } 

Pour vérifier si un fichier existe, importez simplement la bibliothèque java.io. *

 File f = new File(“C:\\File Path”); if(f.exists()){ System.out.println(“Exists”); //if file exists }else{ System.out.println(“Doesn't exist”); //if file doesn't exist } 

Source: http://newsdivariotipo.altervista.org/java-come-controllare-se-un-file-esiste/