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

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

El único pregunta similar en SO se ocupa de escribir el archivo y, por lo tanto, se respondió usando FileWriter que obviamente no es aplicable aquí.

Si es posible, prefiero un real API llamar devolviendo verdadero / falso en lugar de "Llamar a la API para abrir un archivo y detectar cuando arroja una excepción que verifica si hay 'ningún archivo' en el texto", pero puedo vivir con lo último.

preguntado el 29 de noviembre de 09 a las 17:11

También desea agregar que desea verificar los permisos de archivo apropiados: docs.oracle.com/javase/6/docs/api/java/io/File.html java.io.File tiene métodos canRead, canWrite y canExecute para comprobar eso. -

Cabe señalar que esto es peligroso. El sistema de archivos puede cambiar en cualquier momento, incluso justo después de que regrese el método "¿existe este archivo?". Dado que tiene que manejar ese caso de todos modos, tal método es de utilidad cuestionable. Si va a abrir el archivo, la forma correcta de hacerlo es abre el archivo y manejar la excepción relevante. -

@kevin buen punto, pero es de indudable utilidad en un entorno no concurrente, que resultó ser el caso en el que necesitaba esto;) -

@DVK: ¿Está ejecutando un sistema operativo preventivo multitarea? O eso, o es un chip Java especialmente diseñado. Si es el primero, se encuentra en un entorno concurrente. Otros procesos podrían cambiar el sistema de archivos debajo de usted. -

@kevin no es que importe, pero es una aplicación de un solo hilo diseñada para uso personal. Las posibilidades de que su archivo dedicado se cree / cambie de alguna manera desde debajo son increíblemente bajas. -

17 Respuestas

Usar java.io.File:

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

Respondido el 07 de Septiembre de 18 a las 13:09

Hay algunos casos en los que existe () devolverá un resultado incorrecto. Por ejemplo, cuando se utiliza un sistema de archivos NFS, existe un problema con los identificadores de archivos obsoletos: bugs.java.com/bugdatabase/view_bug.do?bug_id=5003595 Es un poco oscuro, pero antes ha sido la causa de algunos errores frustrantes en el código de producción. - GRAZNAR

Utiliza la if(f.isFile()) en lugar de. - León

recuerde usar filePathString.trim () para evitar espacios en blanco - Asim

Recomendaría usar isFile() en lugar de exists(). La mayoría de las veces busca verificar si la ruta apunta a un archivo, no solo a que existe. Recuérdalo 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.

Respondido el 11 de diciembre de 12 a las 06:12

@ ylun.ca ¿El ejemplo incluye subdirectorios? Si quiere preguntar si, dado un directorio actual de /path, new File("file.txt").exists() regresará true si la ruta completa correcta es /path/to/file.txt, la respuesta es un gran no (a menos que otro archivo /path/file.txt existe). - Mateo Leer

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 exists y notExists devuelve falso, no se puede verificar la existencia del archivo. (tal vez no tenga derecho de acceso a este camino)

Puedes comprobar si path es un directorio o archivo normal.

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

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

Por favor, chequee esto Tutorial de Java SE 7.

Respondido 09 ago 19, 17:08

¿Cuáles son las ventajas en comparación con el nuevo archivo (ruta) .existe ()? Para que un palin existe, compruebe - Raghu K Nair

@RaghuKNair java.nio.file.Files.exists() is bastante más rápido que java.io.File.exists() (de mi pequeño punto de referencia en la única computadora que probé: Windows Server 2012 con Java 1.7.0_45 x64). - Mateo

Solo lo probé yo mismo y java.nio.file.Files.exists() fue 5 veces MÁS LENTO que java.io.File.exists. (Win7 Java 1.7.0_79 - x86) - parkerhalo

Esto también tiene la desventaja de que Paths.get lanza una excepción si la cadena no es válida - Richard

Usando Java 8:

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

Respondido el 01 de junio de 16 a las 14:06

Files.exists() toma dos argumentos. Normalmente, querrás algo como Files.exists(path, LinkOption.NOFOLLOW_LINKS ). - Mike C

@MikeC Me pregunto qué método se llama sin el segundo argumento. La Docu ni siquiera muestra ninguna información al respecto. - Poder flor

@PowerFlower: solo hay un método Files.exists (). Sin pasar el segundo argumento, sigue llamando al mismo método. El segundo argumento es la variable varargs y puede pasar 0 o más LinkOptions. - TK8

File f = new File(filePathString); 

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

f.createNewFile();

So f.exists() se puede utilizar para comprobar si dicho archivo existe o no.

contestado el 28 de mayo de 13 a las 12:05

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

respondido 30 nov., 09:15

¿Pearl's -e ¿También se asegura de que la aplicación "pueda leer" el archivo? - lmat - Reincorporar a Monica

Hay varias formas de lograrlo.

  1. En caso de solo por existir. Puede ser un archivo o un directorio.

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

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

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

    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
    

Respondido el 27 de enero de 18 a las 15:01

Usted puede utilizar lo siguiente: File.exists()

contestado el 01 de mayo de 14 a las 12:05

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

Respondido 07 ago 14, 12:08

No es necesario verificar si f! = Null antes de verificar f.exists, si la nueva palabra clave falla, generará una excepción. - Sean AO Harney

no hay verificación si f! = null. f + (...) usa java.io.File.toString - solo alguien

@ solo en realidad, usa String.valueOf(), que maneja nulos - Gigante verde

No lo hagas. Solo coge 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 hay varias razones para no hacerlo, como:

  • duplicar el código
  • el problema de la ventana de tiempo por el cual el archivo puede existir cuando lo prueba pero no cuando lo abre, o viceversa, y
  • el hecho de que, como muestra la existencia de esta pregunta, es posible que realice la prueba incorrecta y obtenga la respuesta incorrecta.

No intente adivinar el sistema. Lo sabe. Y no intente predecir el futuro. En general, la mejor manera de probar si cualquier El recurso está disponible es solo para intentar usarlo.

Respondido el 03 de diciembre de 13 a las 09:12

¿Qué sucede si quiero verificar cada hora para ver si un archivo se ha depositado en una ubicación directa? Tengo un proyecto webMethods que debe verificar si se ha cargado un archivo específico en una unidad específica. ¿Cómo se haría esto? Digamos que quiero comprobar cada hora para ver si el archivo está allí. Puedo usar Java para escribir una clase que haga esto probablemente con un temporizador de algún tipo. - doug hauf

Detectar una excepción es mucho más caro. En mi prueba, verificar el nuevo Archivo (). Existe () fue más de 10 veces más rápido que detectar FileNotFoundException. Por lo tanto, si tiene un escenario en el que normalmente se espera que falten archivos (como el caché de disco), la excepción es incorrecta. Además, adivinar el sistema es genial. - Nick Frolov

@Gnawer No ha abordado ninguno de los problemas que planteé; la excepción solo se lanza cuando el archivo no se puede abrir; y las operaciones que ocurren una vez por hora no requieren microoptimización. Tu sentencia final es una tontería. - user207421

@DougHauf en su caso, no hay problema ya que no intenta hacer nada después de verificar la existencia. Pero el OP pidió específicamente verificar antes de abrir. En este caso, es mejor intentar abrir / abrir el archivo. - Dan Passaro

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.

Respondido el 21 de enero de 15 a las 11:01

Sé que llegué 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 isRegularFile devoluciones false si el archivo no existe. Por tanto, no es necesario comprobar si Files.exists(...).

Tenga en cuenta que otros parámetros son opciones que indican cómo deben manejarse los enlaces. De forma predeterminada, se siguen los enlaces simbólicos.

De la documentación de Java Oracle

Respondido el 19 de Septiembre de 17 a las 10:09

De los documentos de sonar: El método Files.exists tiene un rendimiento notablemente bajo en JDK 8 y puede ralentizar una aplicación significativamente cuando se usa para verificar archivos que en realidad no existen. Lo mismo ocurre con Files.notExists, Files.isDirectory y Files.isRegularFile. La mejor alternativa a esto es: path.toFile().exists() - Genau

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, mejores que JDK.

Respondido el 10 de enero de 19 a las 23:01

Manera de no responder a la pregunta. Estoy de acuerdo en que commons tiene muchas cosas útiles, pero tal vez podríamos dar un paso más y dar una respuesta a la pregunta que hizo el OP. - demonio

Me dio una respuesta suficiente. - bulltorio

Ejemplo simple con buenas prácticas de codificación y que cubre 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

respondido 04 mar '19, 09:03

No use el constructor de archivos con String.
¡Puede que esto no funcione!
En lugar de esto, use URI:

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

Respondido el 01 de diciembre de 16 a las 08:12

Puede que no funcione, ¿por qué no? ¿Y cómo soluciona eso el uso de un URI? - user207421

Tuvimos un problema. f.exists () era cierto e incluso pudimos obtener el contenido del archivo. El problema era que la ruta era incorrecta pero el nombre del archivo estaba bien, incluso este era otro archivo. Al cambiar la llamada al constructor con URI, se solucionó el problema. - iviorel

Puedes hacerlo de esta manera

import java.nio.file.Paths;

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

Respondido 17 Oct 18, 14:10

Para tener en cuenta su respuesta tiene el mejor rendimiento en comparación con File.is Exist() orFiles.isRegularFile() en JDK 8 - Cristián Chaparro A.

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

  1. isFile (): Comprueba si el presentar denotado por este nombre de ruta abstracto es un archivo normal.
  2. existe (): Comprueba si el archivo o directorio denotado por este nombre de ruta abstracto existe. docs.oracle.com

contestado el 03 de mayo de 19 a las 13:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.