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.
Utilisation de 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 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.
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 .
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. 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.
f.isFile() && f.canRead()
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 "));
}
}
Il y a plusieurs façons d'y parvenir.
En cas de juste pour l'existence. Ce pourrait être un fichier ou un répertoire.
new File("/path/to/file").exists();Vérifier le fichier
File f = new File("/path/to/file"); if(f.exists() && f.isFile()) {}Vérifier l'annuaire.
File f = new File("/path/to/file"); if(f.exists() && f.isDirectory()) {}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
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.
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.
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.
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.
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
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
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
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!");
}
new File("/path/to/file").exists();
fera l'affaire
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
}
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 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.
- isFile (): Vérifie si le fichier désigné par ce chemin abstrait est un fichier normal.
- existe (): Vérifie si le fichier ou le répertoire désigné par ce chemin abstrait existe. docs.Oracle.com