¿Cómo verifico si existe un archivo en Java?

¿Cómo puedo verificar si existe un archivo, antes de abrirlo para leerlo en Java (el equivalente de Perl -e $filename )?

La única pregunta similar sobre SO trata con escribir el archivo y, por lo tanto, se respondió usando lo FileWriterque obviamente no es aplicable aquí.

Si es posible, preferiría que una llamada real de la API devuelva verdadero / falso en lugar de algunas "Llamar a la API para abrir un archivo y capturar cuando arroja una excepción que verifica si no hay" archivo "en el texto", pero puedo vivir con el último.

Utilizando java.io.File:

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

Recomendaría usar en isFile()lugar de exists(). La mayoría de las veces está buscando verificar si la ruta apunta a un archivo, no solo que existe. Recuerde que exists()devolverá verdadero si su ruta apunta a un directorio.

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

new File("C:/").exists() devolverá verdadero pero no le permitirá abrirlo y leerlo como un archivo.

Al usar nio en 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 ambos existsy notExistsdevuelven falso, la existencia del archivo no se puede verificar. (tal vez no hay acceso a esta ruta)

Puede verificar si pathes un directorio o archivo normal.

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

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

Consulte este tutorial de Java SE 7 .

Usando Java 8:

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

File f = new File(filePathString); 

Esto no creará un archivo físico. Solo creará un objeto de la clase File. Para crear físicamente un archivo, debe crearlo explícitamente:

f.createNewFile();

Por f.exists()lo tanto, se puede utilizar para verificar si dicho archivo existe o no.

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

Hay múltiples formas de lograr esto.

1. En caso de solo por existencia. Podría ser un archivo o un directorio.

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

2. Verificar archivo

   File f = new File("/path/to/file"); 
     if(f.exists() && f.isFile()) {}

3. Verifique el directorio.

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

4. Java 7 way.

   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

Puedes usar lo siguiente: File.exists()

primer hit para "el archivo java existe" en 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 "));
    }
}

No lo hagas Simplemente tome el FileNotFoundException.El sistema de archivos tiene que probar si el archivo existe de todos modos. No tiene sentido hacer todo eso dos veces, y varias razones para no hacerlo, como:

• duplicar el código
• el problema ventana de tiempo por lo que podría existir el archivo cuando se prueba, pero no cuando se abre, o viceversa, y
• el hecho de que, como lo demuestra la existencia de esta pregunta, podría hacer la prueba incorrecta y obtener la respuesta incorrecta.

No intentes adivinar el sistema. Lo sabe Y no intentes predecir el futuro. En general, la mejor manera de probar si hay algún recurso disponible es simplemente intentar usarlo.

Para mí, una combinación de la respuesta aceptada por Sean AO Harney y el comentario resultante de Cort3z parece ser la mejor solución.

Usó el siguiente fragmento:

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

Espero que esto pueda ayudar a alguien.

Sé que llego un poco tarde en este hilo. Sin embargo, aquí está mi respuesta, válida desde Java 7 en adelante.

El siguiente fragmento

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

es perfectamente satisfactorio, porque el método isRegularFiledevuelve falsesi el archivo no existe. Por lo tanto, no es necesario verificar si Files.exists(...).

Tenga en cuenta que otros parámetros son opciones que indican cómo se deben manejar los enlaces. Por defecto, se siguen los enlaces simbólicos.

De la documentación de Java Oracle

También vale la pena familiarizarse con Commons FileUtils https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html Esto tiene métodos adicionales para administrar archivos y a menudo mejor que JDK.

Por ejemplo, si tiene un directorio de archivos y desea verificar si existe

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

boolean exists = tmpDir.exists();

exists devolverá falso si el archivo no existe

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

Ejemplo simple con buenas prácticas de codificación y cubriendo todos los casos:

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

Referencia y más ejemplos en

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

Si desea buscar un Fileen un directoriodir

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

y verifica el checkresultado

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

hará el truco

No use el constructor de archivos con String.
¡Esto puede no funcionar!
En lugar de este uso URI:

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

File.exists()para verificar si existe un archivo, devolverá un valor booleano para indicar el estado de la operación de verificación; verdadero si el archivo existe; falso si no existe.

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

if(f.exists()){
    System.out.println("File existed");
}else{
    System.out.println("File not found!");
}

Puede usar el siguiente código para verificar:

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

Puedes hacerlo de esta manera

import java.nio.file.Paths;

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

Hay un propósito específico para diseñar estos métodos. No podemos decir que use a alguien para verificar si el archivo existe o no.

1. isFile () : prueba si el archivo indicado por este nombre de ruta abstracto es un archivo normal.
2. exist () : comprueba si el archivo o directorio indicado por este nombre de ruta abstracto existe. docs.oracle.com

Para verificar si existe un archivo, simplemente importe la biblioteca 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
}

Fuente: http://newsdivariotipo.altervista.org/java-come-controllare-se-un-file-esiste/