¿Cómo puedo comprobar si existe un archivo antes de abrirlo para su lectura en Java? (equivalente a la de Perl -e $filename).

La única pregunta similar en LO ofertas con escribir el archivo y así fue contestado mediante FileWriter que obviamente no es aplicable aquí.

Si es posible prefiero una verdadera llamada a la API que devuelve true/false que se opone a «la Llamada de la API para abrir un archivo y captura cuando se lanza una excepción que comprobar ‘no’ archivo de texto», pero puedo vivir con este último.

  • También quiero añadir que desea comprobar permisos de archivo adecuado: docs.oracle.com/javase/6/docs/api/java/io/File.html java.io.El archivo tiene métodos canRead, canWrite, y canExecute para comprobar que.
  • Cabe señalar que esto es peligroso. El sistema de archivos puede cambiar en cualquier momento, incluso inmediatamente después de su «¿este archivo existe» método devuelve. Puesto que usted tiene que manejar ese caso, de todos modos, este método es de dudosa utilidad. Si se va a abrir el archivo, la forma correcta de hacerlo es abrir el archivo y manejar la excepción.
  • buen punto, pero es de indudable utilidad en no concurrentes medio ambiente, que pasó a ser el caso que yo estaba necesitando en este 😉
  • Se ejecuta en un preventivamente multitasked OS? O eso, o es un especialmente diseñado Java chip. En el primer caso, usted está en un entorno concurrente. Otros procesos podría cambiar el sistema de archivos de debajo de usted.
  • no es que importe, pero es un solo subproceso de la aplicación diseñada para el uso personal. Las posibilidades de que ha dedicado el archivo de alguna manera va a ser creado/modificado de debajo de ella son increíblemente bajos.
InformationsquelleAutor DVK | 2009-11-29

23 Comentarios

  1. 1272

    Utilizando java.io.Archivo:

    File f = new File(filePathString);
    if(f.exists() && !f.isDirectory()) { 
        //do something
    }
    • Hay algunos casos en los que existe() devolverá un resultado incorrecto. Por ejemplo, cuando se utiliza un sistema de archivos NFS hay un problema con el rancio identificadores de archivo: bugs.java.com/bugdatabase/view_bug.do?bug_id=5003595 Es una especie de oscuro, pero ha sido la causa de algunos frustrante errores en el código de producción antes.
    • Uso if(f.isFile()) lugar.
    • recuerde usar filePathString.trim() para evitar espacios en blanco
  2. 408

    Me gustaría recomendar el uso de isFile() en lugar de exists(). La mayoría del tiempo usted está buscando para comprobar si los puntos de ruta de acceso a un archivo no sólo que existe. Recuerde que exists() devolverá true si la ruta apunta a un directorio.

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

    new File("C:/").exists() devolverá true, pero no le permitirá abrir y leer como un archivo.

    • En este trabajo si el archivo está en un subdirectorio?
    • El ejemplo incluye subdirectorios? Si te refieres a preguntarse si, dado un directorio actual de /path, new File("file.txt").exists() volverá true si la correcta ruta completa es /path/to/file.txt, la respuesta es un gran no (a menos que otro archivo /path/file.txt existe).
  3. 131

    Mediante 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 existe y notExists devolver false, la existencia del archivo no puede ser verificada. (tal vez no el derecho de acceso a esta ruta)

    Puede verificar si la ruta es el directorio o archivo normal.

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

    Por favor revise esta Java SE 7 tutorial.

    • ¿Cuál es la advatages comparación con el nuevo Archivo(ruta).existe() ? Para una palin existe verificación
    • es mucho más rápido que java.io.File.exists() (desde mi pequeño punto de referencia en el único equipo que he probado: Windows Server 2012 ejecución Java 1.7.0_45 x64).
    • Yo sólo probé a mí mismo y java.nio.file.Files.exists() fue 5 veces más LENTO de java.io.File.exists. (Win7 Java 1.7.0_79 – x86)
    • Esto también tiene la desventaja de que las Rutas de acceso.obtener lanza una excepción si la cadena no es válido
  4. 42

    El Uso De Java 8:

    if(Files.exists(Paths.get(filePathString))) { 
        //do something
    }
    • Files.exists() toma dos argumentos. Normalmente, usted querrá algo como Files.exists(path, LinkOption.NOFOLLOW_LINKS ).
    • Me pregunto qué método se llama sin el segundo argumento. El Docu incluso no mostrar ninguna información sobre eso.
    • No es sólo uno de los Archivos.existe() método. Sin pasar por el segundo argumento, todavía llama al mismo método. El segundo argumento es varargs variable y puede pasar de 0 o más LinkOptions.
  5. 27
    File f = new File(filePathString); 

    Esto no va a crear un archivo físico. Se acaba de crear un objeto de la clase File. Físicamente crear un archivo para crear explícitamente que:

    f.createNewFile();

    Así f.exists() puede ser utilizado para comprobar si un archivo existe o no.

  6. 24
    f.isFile() && f.canRead()
    • Hace de la perla -e también asegurarse de que la aplicación «puede leer» el archivo?
  7. 16

    Hay varias maneras de lograr esto.

    1. En el caso de sólo por la existencia. Se podría archivo o un directorio.

      new File("/path/to/file").exists();
    2. De verificación para el archivo de

      File f = new File("/path/to/file"); 
        if(f.exists() && f.isFile()) {}
    3. De verificación para el Directorio.

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

      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
  8. 14

    primer golpe para «java el archivo 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 hay necesidad de comprobar si f != null antes de la comprobación de f.existe, si la palabra clave new falla se generará una Excepción.
    • no hay ninguna comprobar si f != null. f + (…) los usos de java.io.Archivo.toString
    • en realidad, se utiliza String.valueOf(), que se encarga de valores nulos
  9. 10

    No. Sólo coger la FileNotFoundException. El sistema de archivos tiene que comprobar si el archivo existe de todos modos. No hay ningún punto en hacer todo dos veces, y varias razones para no hacerlo, tales como:

    • el doble del código
    • la ventana de tiempo el problema por el que el archivo puede existir cuando se prueba, pero no cuando se abre, o viceversa, y
    • el hecho de que, como la existencia de esta pregunta muestra, puede hacer que la prueba incorrecta y obtener la respuesta equivocada.

    No trate de adivinar el sistema. Se sabe. Y no se trata de predecir el futuro. En general, la mejor forma de probar si cualquier recurso está disponible a tratar de usar.

    • Lo que si quiero comprobar cada hora para ver si un archivo ha sido depositado en directo y la ubicación. Tengo un webMethods proyecto que tiene que comprobar para ver si un archivo ha sido subido a una unidad específica. ¿Cómo podría esto ser hecho. Digamos que quiero comprobar cada hora para ver si el archivo está ahí. Puedo usar Java para escribir una clase que hace esto probablemente con un temporizador de algún tipo.
    • Captura una excepción es la manera más caro. En mi prueba, la comprobación de Archivo nuevo().existe() más de 10 veces más rápido que la captura de FileNotFoundException. Por lo tanto, si usted tiene un escenario donde los archivos que normalmente se espera a faltar (como caché de disco), excepción que está mal. También, las conjeturas de que el sistema se enfríe.
    • Usted no ha dirigido ninguna de las cuestiones que había planteado; la excepción es sólo produce cuando el archivo no puede ser abierto; y las operaciones que se producen una vez cada hora no requieren de micro-optimización. Su frase final es una tontería.
    • en su caso no hay ningún problema ya que no intento hacer nada después de comprobar la existencia. Pero el OP le preguntó específicamente para comprobar antes de la apertura. En este caso es mejor try/catch abierto el archivo.
  10. 8

    Para mí una combinación de la aceptó responder por Sean A. O. Harney y el consiguiente comentario por Cort3z parece ser la mejor solución.

    Utiliza el siguiente fragmento de código:

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

    Espero que esto pueda ayudar a alguien.

  11. 4

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

    El siguiente fragmento de código

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

    es perfectamente satifactory, debido a que el método de isRegularFile devuelve false si el archivo no existe. Por lo tanto, no hay necesidad de comprobar si Files.exists(...).

    Nota que los demás parámetros son opciones que indica cómo los enlaces deben ser manejados. Por defecto, los enlaces simbólicos son seguidos.

    A partir de Java documentación de Oracle

    • A partir de sonar docs: Los Archivos.existe método tiene notablemente pobre rendimiento en el JDK 8, y puede retrasar una aplicación de manera significativa cuando se utiliza para comprobar los archivos que realmente no existen. lo mismo va para Files.notExists, Files.isDirectory y Files.isRegularFile. La mejor alternativa a esto es: path.toFile().exists()
  12. 4

    También merece la pena familiarizarse con Commons FileUtils https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html
    Este tiene otros métodos para la gestión de archivos y a menudo mejor que el JDK.

    • La manera de no responder a la pregunta. Estoy de acuerdo commons tiene un montón de cosas útiles, pero tal vez podríamos ir un paso más allá y ofrecer una respuesta a la pregunta del OP preguntó.
    • Él dio suficiente de una respuesta para mí.
  13. 2

    Simple ejemplo de buenas prácticas de codificación y que abarque 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);
                }
            }
        }

    De referencia y más ejemplos en

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

  14. 1

    Si desea comprobar un File en un directorio dir

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

    y comprobar la check resultado

  15. 1

    No utilizar el Archivo constructor de la Cadena.

    Esto puede que no funcione!

    En lugar de que este uso de URI:

    File f = new File(new URI("file:///"+filePathString.replace('\', '/')));
    if(f.exists() && !f.isDirectory()) { 
        //to do
    }
    • Ella no estaba trabajando con Cadena y me pregunto ¿por qué?
    • Puede que no funcione ¿por qué no? Y cómo hace uso de una URI arreglar eso?
    • Hemos tenido un problema. f.existe() era cierto y que incluso podría obtener el contenido del archivo. El problema era que el camino estaba mal, pero el nombre del archivo que estaba bien, incluso este fue otro archivo. Cambiar la llamada al constructor con URI, se ha solucionado el problema.
  16. 1

    File.exists() para verificar si un archivo existe, se devuelve un valor booleano para indicar la operación de comprobación de estado; true si el archivo se existido; false 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!");
    }
  17. 0

    Puede utilizar el siguiente código de verificación:

    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;
            }
        }
    }
  18. 0

    Puede hacer de esta manera

    import java.nio.file.Paths;
    
    String file = "myfile.sss";
    if(Paths.get(file).toFile().isFile()){
        //...do somethinh
    }
    • Para tomar en cuenta tu respuesta tiene el mejor rendimiento en comparación con File.is Exist() oFiles.isRegularFile() en JDK 8
  19. 0

    Hay propósito específico para el diseño de estos métodos. No podemos decir que el uso de cualquiera de verificación archivo existe o no.

    1. isFile(): si las Pruebas de la archivo denotado por este resumen, una ruta es un archivo normal.
    2. existe(): si las Pruebas de la archivo o directorio denotado por este resumen, una ruta existe.
      docs.oracle.com

Dejar respuesta

Please enter your comment!
Please enter your name here