Comment vérifier si un fichier existe en Java?


842

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.


3
Également ajouter que vous voulez vérifier les autorisations de fichiers appropriés: docs.oracle.com/javase/6/docs/api/java/io/File.html java.io.File a des méthodes canRead, canWriteet canExecutepour vérifier que .
Kirkland

6
Il convient de noter que cela est dangereux. Le système de fichiers peut changer à tout moment, y compris juste après le retour de votre méthode "ce fichier existe-t-il". Comme vous devez de toute façon gérer ce cas, une telle méthode est d'une utilité discutable. Si vous allez ouvrir le fichier, la façon correcte de le faire est d' ouvrir le fichier et de gérer l'exception appropriée.
Kevin

1
@kevin bon point, mais c'est d'une utilité incontestable dans un environnement non simultané, ce qui s'est avéré être le cas dans lequel j'avais besoin de cela;)
DVK

@DVK: exécutez-vous sur un système d'exploitation multitâche préemptif? Soit ça, soit c'est une puce Java spécialement conçue . Si le premier, vous êtes dans un environnement simultané. D'autres processus pourraient changer le système de fichiers sous vous.
Kevin

2
@kevin ce n'est pas important mais c'est une application à un seul thread conçue pour un usage personnel. Les chances que son fichier dédié soit en quelque sorte créé / modifié par-dessous sont incroyablement faibles.
DVK

Réponses:


1342

En utilisant java.io.File:

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

15
Il existe des cas où exist () renvoie un résultat incorrect. Par exemple, lors de l'utilisation d'un système de fichiers NFS, il y a un problème avec les poignées de fichier périmées : bugs.java.com/bugdatabase/view_bug.do?bug_id=5003595 C'est un peu obscur, mais cela a été la cause de quelques bugs frustrants dans le code de production avant.
2017 des TCA

22
Utilisez if(f.isFile())plutôt.
Leon

1
n'oubliez pas d'utiliser filePathString.trim () pour éviter les espaces blancs
Asim

427

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.


1
@ ylun.ca L'exemple comprend des sous-répertoires? Si vous voulez demander si, étant donné un répertoire courant de /path, new File("file.txt").exists()retournera truesi le chemin complet est correct /path/to/file.txt, la réponse est un grand non (à moins qu'un autre fichier /path/file.txtn'existe).
Matthew Read

149

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 .


2
Quels sont les avantages par rapport au nouveau fichier (chemin) .exists ()? Pour un palin existe, vérifiez
Raghu K Nair

2
@RaghuKNair java.nio.file.Files.exists()est beaucoup plus rapide que java.io.File.exists()(à partir de ma petite référence sur le seul ordinateur que j'ai testé: Windows Server 2012 exécutant Java 1.7.0_45 x64).
Matthieu

1
Je viens de l'essayer moi-même et j'étaisjava.nio.file.Files.exists() 5 fois plus lent que java.io.File.exists. (Win7 Java 1.7.0_79 - x86)
ParkerHalo

Cela présente également l'inconvénient que Paths.get lève une exception si la chaîne n'est pas valide
Richard

46

Utilisation de Java 8:

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

2
Files.exists()prend deux arguments. En règle générale, vous voudrez quelque chose comme Files.exists(path, LinkOption.NOFOLLOW_LINKS ).
Mike C

1
@MikeC Je me demande quelle méthode est appelée sans le deuxième argument. Le Docu ne montre même aucune information à ce sujet.
PowerFlower

1
@PowerFlower: Il n'y a qu'une seule méthode Files.exists (). Sans passer le deuxième argument, il appelle toujours la même méthode. Le deuxième argument est une variable varargs et peut transmettre 0 ou plusieurs LinkOptions.
TK8

27
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.



16

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


14

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

1
Il n'est pas nécessaire de vérifier si f! = Null avant de vérifier f.exists, si le nouveau mot clé échoue, il générera une exception.
Sean AO Harney

il n'y a pas de contrôle si f! = null. f + (...) utilise java.io.File.toString
juste quelqu'un

@just en fait, il utilise String.valueOf(), qui gère les
valeurs

12

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.


Et si je veux vérifier toutes les heures pour voir si un fichier a été déposé directement sur un emplacement. J'ai un projet webMethods qui doit vérifier si un fichier spécifique a été téléchargé sur un lecteur spécifique. Comment cela se ferait-il? Disons que je veux vérifier toutes les heures pour voir si le fichier est là. Je peux utiliser Java pour écrire une classe qui le fait probablement avec un minuteur quelconque.
Doug Hauf

2
Attraper une exception est beaucoup plus cher. Dans mon test, la vérification de nouveau File (). Exist () était plus de 10 fois plus rapide que la capture de FileNotFoundException. Donc, si vous avez un scénario où des fichiers normalement manquants (comme le cache disque), l'exception est incorrecte. En outre, il est cool de deviner le système.
Nick Frolov

1
@Gnawer Vous n'avez abordé aucun des problèmes que j'ai soulevés; l'exception n'est levée que lorsque le fichier ne peut pas être ouvert; et les opérations qui se produisent une fois par heure ne nécessitent pas de micro-optimisation. Votre dernière phrase est absurde.
Marquis de Lorne

1
@DougHauf dans votre cas, il n'y a aucun problème puisque vous n'essayez de rien faire après avoir vérifié l'existence. Mais le PO a demandé spécifiquement de vérifier avant l'ouverture. Dans ce cas, il vaut mieux essayer / attraper le fichier ouvert.
Dan Passaro

8

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.


4

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


À partir des documents sonar: la méthode Files.exists a des performances sensiblement médiocres dans JDK 8 et peut ralentir considérablement une application lorsqu'elle est utilisée pour vérifier des fichiers qui n'existent pas réellement. Il en va de même Files.notExists, Files.isDirectoryet Files.isRegularFile. la meilleure alternative à cela est:path.toFile().exists()
Genaut

4

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.


19
Manière de ne pas répondre à la question. Je suis d'accord que les communs ont beaucoup de choses utiles, mais peut-être pourrions-nous aller un peu plus loin et répondre à la question posée par le PO.
demongolem

4
Il a donné assez de réponse pour moi.
bulltorious


2

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


1

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



1

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
}

Peut ne pas fonctionner pourquoi pas? Et comment l'utilisation d'un URI corrige-t-elle cela?
Marquis de Lorne

Nous avons eu un problème. f.exists () était vrai et nous pouvions même obtenir le contenu du fichier. Le problème était que le chemin était incorrect mais le nom de fichier était OK, même c'était un autre fichier. La modification de l'appel du constructeur avec l'URI a résolu le problème.
iviorel

1

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

0

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

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
}

Pour prendre en compte votre réponse a la meilleure performance par rapport à File.is Exist()ou Files.isRegularFile()dans JDK 8
Cristian Chaparro A.

0

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

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.