web-dev-qa-db-fra.com

Comment vérifier si un fichier existe en Java?

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

La seule question similaire sur SO traite de l'écriture du fichier et a donc été répondue à l'aide de FileWriter qui n'est évidemment pas applicable ici.

Si possible, je préférerais un véritable appel d'API renvoyant la valeur true/false, par opposition à "Appelez l'API pour ouvrir un fichier et intercepter une exception lancée qui vérifie l'absence de fichier dans le texte", mais je peux vivre avec le dernier.

739
DVK

Utilisation de Java.io.File :

File f = new File(filePathString);
if(f.exists() && !f.isDirectory()) { 
    // do something
}
1237
Sean A.O. Harney

Je recommanderais d'utiliser isFile() au lieu de exists(). La plupart du temps, vous cherchez à vérifier si le chemin d'accès pointe vers un fichier et non seulement son existence. Rappelez-vous que exists() renverra true si votre chemin d'accès pointe vers un répertoire.

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

new File("C:/").exists() retournera true mais ne vous permettra pas de l'ouvrir et de le lire sous forme de fichier.

398
Chris Dail

En utilisant nio dans Java SE 7,

import Java.nio.file.*;

Path path = Paths.get(filePathString);

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 le droit d'accès à 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 ceci Tutoriel Java SE 7 .

129
Wonil

Utilisation de Java 8:

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

Cela ne créera pas de fichier physique. Fera juste créer un objet de la classe File. Pour créer physiquement un fichier, vous devez le créer explicitement:

f.createNewFile();

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

27
rizwan
f.isFile() && f.canRead()
24
jhumble

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

14
Francis Upton

premier coup pour "le fichier Java existe" sur google:

import Java.io.*;

public class FileTest {
    public static void main(String args[]) {
        File f = new File(args[0]);
        System.out.println(f + (f.exists()? " is found " : " is missing "));
    }
}
14
just somebody

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érifier l'annuaire.

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

    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
    
13
Raghu K Nair

Ne pas Attrapez juste le FileNotFoundException. Le système de fichiers doit vérifier si le fichier existe de toute façon. Il ne sert à rien de faire tout cela deux fois et plusieurs raisons de ne pas le faire, telles que:

  • double 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 inversement, et
  • le fait que, comme le montre l'existence de cette question, vous risquez de vous tromper de test et d'obtenir une réponse erronée.

N'essayez pas de deviner le système. Il sait. Et n'essayez pas de prédire l'avenir. En général, le meilleur moyen de vérifier si une ressource est disponible consiste à essayer de l’utiliser.

9
user207421

Pour moi, une combinaison de la réponse acceptée par Sean A.O. Harney et le commentaire de Cort3z qui en résulte semblent être la meilleure solution.

Utilisé l'extrait suivant:

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

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

8
X-Fate

Il est également intéressant de se familiariser avec Commons FileUtils https://commons.Apache.org/proper/commons-io/javadocs/api-2.5/org/Apache/commons/io/FileUtils.html a des méthodes supplémentaires pour gérer les fichiers et souvent mieux que JDK.

4
peter.murray.rust

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

L'extrait suivant

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

est parfaitement satifactory, 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 paramètres sont des options indiquant comment les liens doivent être gérés. Par défaut, les liens symboliques sont suivis.

D'après la documentation Java Oracle

4
avi.elkharrat

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

File tmpDir = new File("/var/tmp");

boolean exists = tmpDir.exists();

exists retournera false si le fichier n'existe pas

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

3
ID127898

Exemple simple avec de bonnes pratiques de codage et couvrant tous les cas:

 private static void fetchIndexSafely(String url) throws FileAlreadyExistsException {
        File f = new File(Constants.RFC_INDEX_LOCAL_NAME);
        if (f.exists()) {
            throw new FileAlreadyExistsException(f.getAbsolutePath());
        } else {
            try {
                URL u = new URL(url);
                FileUtils.copyURLToFile(u, f);
            } catch (MalformedURLException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                Logger.getLogger(RfcFetcher.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

Référence et plus d'exemples sur

https://zgrepcode.com/examples/Java/java/nio/file/filealreadyexistsexception-implementations

2
Amandeep Singh

Si vous voulez rechercher une File dans un répertoire dir

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

et vérifiez le résultat check

1
user3618182

File.exists() pour vérifier si un fichier existe, il retournera une valeur booléenne pour indiquer l'état de l'opération de vérification true si le fichier existe déjà; faux sinon existe.

File f = new File("c:\\test.txt");

if(f.exists()){
    System.out.println("File existed");
}else{
    System.out.println("File not found!");
}
1
KIBOU Hassan
new File("/path/to/file").exists(); 

fera l'affaire

1
user4833142

N'utilisez pas le constructeur de fichier avec String.
Cela peut ne pas fonctionner! 
Au lieu de cette utilisation, URI:

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

Vous pouvez utiliser le code suivant pour vérifier:

import Java.io.File;
class Test{
    public static void main(String[] 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;
        }
    }
}
0
Pankti

Vous pouvez le faire de cette façon

import Java.nio.file.Paths;

String file = "myfile.sss";
if(Paths.get(file).toFile().isFile()){
    //...do somethinh
}
0
Rodrigo Pavan

Il y a un but spécifique pour concevoir ces méthodes. Nous ne pouvons pas dire d'utiliser quelqu'un pour vérifier si le fichier existe ou non.

  1. isFile (): Vérifie si le fichier désigné par ce chemin abstrait est un fichier normal.
  2. existe (): Vérifie si le fichier ou le répertoire désigné par ce chemin abstrait existe. docs.Oracle.com
0
Atul Jain