file-io créer - Comment vérifier si un fichier existe en Java?





supprimer fichiers (17)


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

Comment puis-je vérifier si un fichier existe, avant de l'ouvrir pour la lecture 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épondu en utilisant FileWriter qui n'est évidemment pas applicable ici.

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




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



En utilisant Java 8:

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



N'utilisez pas le constructeur de fichier 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
}



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



Je sais que je suis un peu en retard dans ce sujet. 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 isRegularFile retourne 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.

De la documentation Java Oracle




File f = new File(filePathString); 

Cela ne créera pas un fichier physique. Je vais 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.




Si vous voulez rechercher un File dans un répertoire

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

et vérifiez le résultat de la check







Ne pas. FileNotFoundException. simplement l' FileNotFoundException. Le système de fichiers doit tester si le fichier existe quand même. 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 temporelle selon 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 tester si une ressource est disponible est juste 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çons

    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
    



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



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

fera l'affaire




Vous pouvez utiliser ce qui suit: File.exists()




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 notExists renvoie false, l'existence du fichier ne peut pas être vérifiée. (peut-être pas d'accès à ce chemin)

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

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.io.File :

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



Notez que cette approche est plus biaisée et moins efficace qu'une approche nextInt , https://.com/a/738651/360211

Un modèle standard pour accomplir ceci est:

Min + (int)(Math.random() * ((Max - Min) + 1))

La fonction de bibliothèque Java Math Math.random () génère une valeur double dans la plage [0,1) . Notez que cette plage n'inclut pas le 1.

Pour obtenir d'abord une plage de valeurs spécifique, vous devez multiplier par l'ampleur de la plage de valeurs que vous souhaitez couvrir.

Math.random() * ( Max - Min )

Cela renvoie une valeur dans la plage [0,Max-Min) , où 'Max-Min' n'est pas inclus.

Par exemple, si vous voulez [5,10) , vous devez couvrir cinq valeurs entières pour pouvoir utiliser

Math.random() * 5

Cela renverrait une valeur dans l'intervalle [0,5) , où 5 n'est pas inclus.

Vous devez maintenant déplacer cette plage vers la plage que vous ciblez. Vous faites cela en ajoutant la valeur Min.

Min + (Math.random() * (Max - Min))

Vous allez maintenant obtenir une valeur dans la plage [Min,Max) . Suivant notre exemple, cela signifie [5,10) :

5 + (Math.random() * (10 - 5))

Mais cela n'inclut toujours pas Max et vous obtenez une double valeur. Pour que la valeur Max incluse, vous devez ajouter 1 à votre paramètre de plage (Max - Min) , puis tronquer la partie décimale en convertissant en un int. Ceci est accompli via:

Min + (int)(Math.random() * ((Max - Min) + 1))

Et voila. Un nombre entier aléatoire compris entre [Min,Max] ou l'exemple [5,10] :

5 + (int)(Math.random() * ((10 - 5) + 1))




java file-io io