Comment vérifier si un fichier existe en Java?

Comment puis-je vérifier si un fichier existe, avant de l'ouvrir pour la lecture en Java (l'équivalent de Perl -e $filename )?

Le seul question similaire sur SO concerne la rédaction du dossier et a donc été répondue en utilisant FileWriterce qui n'est évidemment pas applicable ici.

Si possible je préfère une vraie API appel d' renvoyant vrai / faux, par opposition à certains "Appeler l'API pour ouvrir un fichier et intercepter quand il lève une exception que vous vérifiez pour" aucun fichier "dans le texte", mais je peux vivre avec le dernier.

En utilisant java.io.File:

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

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, non seulement qu'il existe. N'oubliez pas que exists()cela retournera vrai si votre chemin d'accès 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(filePathString);

if (Files.exists(path)) {
  // file exist
}

if (Files.notExists(path)) {
  // file is not exist
}

Si les deux existsetnotExists retournent false, l'existence du fichier ne peut pas être vérifiée. (peut-être pas de droit d'accès à ce chemin)

Vous pouvez vérifier s'il paths'agit d'un répertoire ou d'un fichier normal.

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

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

Veuillez consulter ce tutoriel Java SE 7 .

Utilisation de Java 8:

if(Files.exists(Paths.get(filePathString))) { 
    // do something
}

File f = new File(filePathString); 

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

f.createNewFile();

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

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

Il existe plusieurs façons d'y parvenir.

1. En cas de juste pour l'existence. Il peut s'agir d'un fichier ou d'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 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

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

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 "));
    }
}

Non. Il suffit d'attraper le FileNotFoundException.système de fichiers pour 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 fenêtre de synchronisation dans lequel le fichier peut exister lorsque vous testez mais pas lorsque vous l'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 tester si une ressource est disponible est simplement d'essayer de l'utiliser.

Pour moi, une 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 de code suivant:

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

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

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

L'extrait suivant

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

est parfaitement satisfaisant, car la méthode isRegularFileretourne falsesi le fichier n'existe pas. Par conséquent, pas besoin de vérifier si Files.exists(...).

Notez que d'autres paramètres sont des options indiquant comment les liens doivent être traités. Par défaut, les liens symboliques sont suivis.

À partir de la documentation Java Oracle

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

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 false si le fichier n'existe pas

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

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 autres exemples sur

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

Si vous souhaitez rechercher un Filedans un répertoiredir

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

et vérifier le checkrésultat

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

fera l'affaire

N'utilisez pas le constructeur de fichiers avec String.
Cela peut ne pas fonctionner!
Au lieu de cela, utilisez l'URI:

File f = new File(new URI("file:///"+filePathString.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 l'état 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!");
}

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;
        }
    }
}

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
}

Il existe un objectif spécifique pour concevoir ces méthodes. Nous ne pouvons pas dire qu'il faut utiliser quelqu'un pour vérifier l'existence du fichier ou non.

1. isFile () : teste si le fichier indiqué par ce nom de chemin abstrait est un fichier normal.
2. exist () : teste si le fichier ou le répertoire indiqué par ce nom de chemin abstrait existe. docs.oracle.com

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/