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


842

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


3
También quiero añadir que le gustaría que para comprobar los permisos de archivo apropiados: docs.oracle.com/javase/6/docs/api/java/io/File.html java.io.File tiene métodos canRead, canWritey canExecutepara comprobar que .
Kirkland

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

1
@kevin buen punto, pero es de utilidad incuestionable en un entorno no concurrente, que resultó ser el caso en el que lo necesitaba;)
DVK

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

2
@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 son increíblemente bajas.
DVK

Respuestas:


1342

Utilizando java.io.File:

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

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

22
Usar en su if(f.isFile())lugar.
Leon

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

427

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.


1
@ ylun.ca ¿El ejemplo incluye subdirectorios? Si quiere preguntar si, dado un directorio actual de /path, new File("file.txt").exists()volverá truesi la ruta completa correcta es /path/to/file.txt, la respuesta es un gran no (a menos que /path/file.txtexista otro archivo ).
Matthew leyó el

149

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 .


2
¿Cuáles son las ventajas en comparación con el nuevo archivo (ruta) .exists ()? Para un cheque existe cheque
Raghu K Nair

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

1
Lo intenté yo mismo y java.nio.file.Files.exists()fui 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

46

Usando Java 8:

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

2
Files.exists()Toma dos argumentos. Por lo general, querrás algo así Files.exists(path, LinkOption.NOFOLLOW_LINKS ).
Mike C

1
@MikeC Me pregunto qué método se llama sin el segundo argumento. El Docu ni siquiera muestra información al respecto.
PowerFlower

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

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



16

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


14

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

1
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 el

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

@just realmente, usa String.valueOf(), que maneja nulos
GreenGiant

12

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.


¿Qué sucede si quiero verificar cada hora para ver si un archivo se ha depositado en una ubicación directa? Tengo un proyecto de webMethods que tiene que verificar para ver si un archivo específico se ha cargado en una unidad específica. ¿Cómo se haría esto? Digamos que quiero verificar 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

2
Capturar una excepción es mucho más costoso. En mi prueba, verificar nuevo File (). Exist () fue más de 10 veces más rápido que detectar FileNotFoundException. Por lo tanto, si tiene un escenario en el que normalmente faltan archivos (como el caché de disco), la excepción es incorrecta. Además, adivinar el sistema es genial.
Nick Frolov

1
@Gnawer No ha abordado ninguno de los problemas que planteé; la excepción solo se produce cuando el archivo no se puede abrir; y las operaciones que ocurren una vez por hora no requieren micro-optimización. Tu oración final no tiene sentido.
Marqués de Lorne

1
@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 / capturar el archivo abierto.
Dan Passaro

8

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.


4

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


De documentos de sonda: el método Files.exists tiene un rendimiento notablemente bajo en JDK 8, y puede ralentizar significativamente una aplicación cuando se usa para verificar archivos que realmente no existen. Lo mismo ocurre Files.notExists, Files.isDirectoryy Files.isRegularFile. la mejor alternativa a esto es:path.toFile().exists()
Genaut

4

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.


19
Manera de no responder 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.
demongolem

44
Me dio suficiente respuesta para mí.
tormentoso


2

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


1

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



1

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
}

Puede no funcionar, ¿por qué no? ¿Y cómo se soluciona el uso de un URI?
Marqués de Lorne

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 del constructor con URI, se solucionó el problema.
iviorel

1

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

0

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

0

Puedes hacerlo de esta manera

import java.nio.file.Paths;

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

Para tener en cuenta su respuesta tiene el mejor rendimiento en comparación con File.is Exist()o Files.isRegularFile()en JDK 8
Cristian Chaparro A.

0

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.