Lista de todos los archivos de un directorio de forma recursiva con Java

Question

que tienen esta función que imprime el nombre de todos los archivos en un directorio de forma recursiva. El problema es que mi código es muy lento porque tiene que acceder a un dispositivo de red remoto con cada iteración.

Mi plan es la primera carga todos los archivos del directorio recursivamente y luego, después de que ir a través de todos los archivos con la expresión regular para filtrar todos los archivos que no quiero. ¿Alguien tiene una mejor sugerencia?

public static printFnames(String sDir){ 
 File[] faFiles = new File(sDir).listFiles(); 
 for(File file: faFiles){ 
    if(file.getName().matches("^(.*?)")){ 
  System.out.println(file.getAbsolutePath()); 
    } 
  if(file.isDirectory()){ 
    printFnames(file.getAbsolutePath()); 
  } 
 } 
} 

Esto es sólo una prueba más adelante no voy a utilizar el código de esta forma, en vez voy a añadir la ruta y la fecha de modificación de cada archivo que coincide con una expresión regular avanzada para una matriz.

Answer 1

Suponiendo que este es el código de producción real que va a escribir, entonces sugiero usar la solución para este tipo de cosas que ya se ha resuelto - Apache Commons IO, específicamente FileUtils.listFiles(). Maneja directorios anidados, filtros (basados ​​en nombre, tiempo de modificación, etc.).

Por ejemplo, para su expresión regular:

Collection files = FileUtils.listFiles(
    dir, 
    new RegexFileFilter("^(.*?)"), 
    DirectoryFileFilter.DIRECTORY 
); 

Esto hará de forma recursiva buscar archivos que coinciden con la expresión regular ^(.*?), la devolución de los resultados como una colección.

Vale la pena señalar que esto no más rápido que estar rodando su propio código, que está haciendo la misma cosa - pesca de arrastre de un sistema de archivos en Java es simplemente lento. La diferencia es que la versión de Apache Commons no tendrá errores.

Answer 2

se siente como si fuera estúpida acceso al sistema de archivos y obtener el contenido de cada subdirectorio en vez de conseguir todo a la vez.

Su sensación es erróneo. Así es como funcionan los sistemas de archivos. No hay una forma más rápida (excepto cuando tiene que hacer esto repetidamente o para diferentes patrones, puede almacenar en caché todas las rutas de archivos en la memoria, pero luego tiene que lidiar con la invalidación de caché, es decir, qué sucede cuando se agregan/eliminan/renombran archivos mientras la aplicación se ejecuta).

Answer 3

interfaz de Java para leer contenido de la carpeta de sistema de archivos no es de buen calidad (como usted ha descubierto). JDK 7 soluciona esto con una interfaz completamente nueva para este tipo de cosas, que debería llevar el rendimiento nativo a este tipo de operaciones.

El tema central es que Java hace una llamada al sistema nativo para cada archivo. En una interfaz de baja latencia, esto no es gran cosa, pero en una red con una latencia incluso moderada, realmente se suma. Si perfila su algoritmo arriba, encontrará que la mayor parte del tiempo se gasta en la molesta llamada a directorio() porque eso significa que está incurriendo en un viaje de ida y vuelta para cada llamada a isDirectory(). La mayoría de los sistemas operativos modernos pueden proporcionar este tipo de información cuando la lista de archivos/carpetas se solicitó originalmente (en lugar de consultar cada ruta de archivo individual para sus propiedades).

Si no puede esperar para JDK7, una estrategia para abordar esta latencia es utilizar varios subprocesos y utilizar un ExecutorService con un máximo de # subprocesos para realizar su recursión. No es genial (tienes que lidiar con el bloqueo de tus estructuras de datos de salida), pero será muchísimo más rápido que hacerlo con un solo hilo.

En todas sus discusiones sobre este tipo de cosas, le recomiendo que lo compare con lo mejor que podría hacer usando código nativo (o incluso un script de línea de comandos que hace más o menos lo mismo). Decir que lleva una hora atravesar una estructura de red en realidad no significa mucho. Decirnos que puedes hacerlo nativo en 7 segundos, pero lleva una hora en Java atraerá la atención de las personas.

Answer 4

Para que lo sepas isDirectory() es un método bastante lento. Lo encuentro bastante lento en mi buscador de archivos. Voy a buscar en una biblioteca para reemplazarlo con código nativo.

Answer 5

La manera más eficiente que encontré al tratar con millones de carpetas y archivos es capturar la lista de directorios a través del comando DOS en algún archivo y analizarlo. Una vez que haya analizado los datos, puede hacer análisis y calcular estadísticas.

Answer 6

Esta función probablemente listará todo el nombre del archivo y su ruta desde su directorio y sus subdirectorios.

public void listFile(String pathname) { 
    File f = new File(pathname); 
    File[] listfiles = f.listFiles(); 
    for (int i = 0; i < listfiles.length; i++) { 
     if (listfiles[i].isDirectory()) { 
      File[] internalFile = listfiles[i].listFiles(); 
      for (int j = 0; j < internalFile.length; j++) { 
       System.out.println(internalFile[j]); 
       if (internalFile[j].isDirectory()) { 
        String name = internalFile[j].getAbsolutePath(); 
        listFile(name); 
       } 

      } 
     } else { 
      System.out.println(listfiles[i]); 
     } 

    } 

} 

Answer 7

La forma más rápida de obtener el contenido de un directorio utilizando Java 7 NIO:

import java.nio.file.DirectoryStream; 
import java.nio.file.Files; 
import java.nio.file.FileSystems; 
import java.nio.file.Path; 

... 

Path dir = FileSystems.getDefault().getPath(filePath); 
DirectoryStream<Path> stream = Files.newDirectoryStream(dir); 
for (Path path : stream) { 
    System.out.println(path.getFileName()); 
} 
stream.close(); 

Answer 8

Con Java 7 una manera más rápida que caminar a través de un árbol de directorios se introdujo con la funcionalidad Paths y Files. Son mucho más rápidos que el "viejo" File manera.

Este sería el código para caminar a través y comprobar los nombres de ruta con una expresión regular:

public final void test() throws IOException, InterruptedException { 
    final Path rootDir = Paths.get("path to your directory where the walk starts"); 

    // Walk thru mainDir directory 
    Files.walkFileTree(rootDir, new FileVisitor<Path>() { 
     // First (minor) speed up. Compile regular expression pattern only one time. 
     private Pattern pattern = Pattern.compile("^(.*?)"); 

     @Override 
     public FileVisitResult preVisitDirectory(Path path, 
       BasicFileAttributes atts) throws IOException { 

      boolean matches = pattern.matcher(path.toString()).matches(); 

      // TODO: Put here your business logic when matches equals true/false 

      return (matches)? FileVisitResult.CONTINUE:FileVisitResult.SKIP_SUBTREE; 
     } 

     @Override 
     public FileVisitResult visitFile(Path path, BasicFileAttributes mainAtts) 
       throws IOException { 

      boolean matches = pattern.matcher(path.toString()).matches(); 

      // TODO: Put here your business logic when matches equals true/false 

      return FileVisitResult.CONTINUE; 
     } 

     @Override 
     public FileVisitResult postVisitDirectory(Path path, 
       IOException exc) throws IOException { 
      // TODO Auto-generated method stub 
      return FileVisitResult.CONTINUE; 
     } 

     @Override 
     public FileVisitResult visitFileFailed(Path path, IOException exc) 
       throws IOException { 
      exc.printStackTrace(); 

      // If the root directory has failed it makes no sense to continue 
      return path.equals(rootDir)? FileVisitResult.TERMINATE:FileVisitResult.CONTINUE; 
     } 
    }); 
} 

Answer 9

Este es un método muy simple recursiva para obtener todos los archivos de una raíz dada.

Utiliza la clase Java 7 NIO Path.

private List<String> getFileNames(List<String> fileNames, Path dir) { 
    try(DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) { 
     for (Path path : stream) { 
      if(path.toFile().isDirectory()) { 
       getFileNames(fileNames, path); 
      } else { 
       fileNames.add(path.toAbsolutePath().toString()); 
       System.out.println(path.getFileName()); 
      } 
     } 
    } catch(IOException e) { 
     e.printStackTrace(); 
    } 
    return fileNames; 
} 

Answer 10

esto va a funcionar muy bien ... y su recursiva

File root = new File("ROOT PATH"); 
for (File file : root.listFiles()) 
{ 
    getFilesRecursive(file); 
} 


private static void getFilesRecursive(File pFile) 
{ 
    for(File files : pFile.listFiles()) 
    { 
     if(files.isDirectory()) 
     { 
      getFilesRecursive(files); 
     } 
     else 
     { 
      // do your thing 
      // you can either save in HashMap and use it as 
      // per your requirement 
     } 
    } 
} 

Answer 11

Esto funcionará bien

public void displayAll(File path){  
    if(path.isFile()){ 
     System.out.println(path.getName()); 
    }else{ 
     System.out.println(path.getName());   
     File files[] = path.listFiles(); 
     for(File dirOrFile: files){ 
      displayAll(dirOrFile); 
     } 
    } 
} 

Answer 12

personalmente me gusta esta versión de FileUtils. Aquí hay un ejemplo que encuentra todos los archivos MP3 o FLACS en un directorio o cualquiera de sus subdirectorios:

String[] types = {"mp3", "flac"}; 
Collection<File> files2 = FileUtils.listFiles(/path/to/your/dir, types , true); 

Answer 13

import java.io.*; 

public class MultiFolderReading { 

public void checkNoOfFiles (String filename) throws IOException { 

    File dir=new File(filename); 
    File files[]=dir.listFiles();//files array stores the list of files 

for(int i=0;i<files.length;i++) 
    { 
     if(files[i].isFile()) //check whether files[i] is file or directory 
     { 
      System.out.println("File::"+files[i].getName()); 
      System.out.println(); 

     } 
     else if(files[i].isDirectory()) 
     { 
      System.out.println("Directory::"+files[i].getName()); 
      System.out.println(); 
      checkNoOfFiles(files[i].getAbsolutePath()); 
     } 
    } 
} 

public static void main(String[] args) throws IOException { 

    MultiFolderReading mf=new MultiFolderReading(); 
    String str="E:\\file"; 
    mf.checkNoOfFiles(str); 
    } 
} 

Answer 14

En Java 8, que es un 1-liner a través de Files.find() con un arbitrariamente grande de profundidad (por ejemplo 999) y BasicFileAttributes de isRegularFile()

public static printFnames(String sDir) { 
    Files.find(Paths.get(sDir), 999, (p, bfa) -> bfa.isRegularFile()).forEach(System.out::println); 
} 

para añadir más filtrado, mejorar la lambda, por ejemplo todos los archivos jpg modificados en las últimas 24 horas:

(p, bfa) -> bfa.isRegularFile() 
    && p.getFileName().toString().matches(".*\\.jpg") 
    && bfa.lastModifiedTime().toMillis() > System.currentMillis() - 86400000 

Answer 15

En Guava no tiene que esperar que se le devuelva una colección, pero puede iterar sobre los archivos.Es fácil imaginar una interfaz IDoSomethingWithThisFile en la firma de la función a continuación:

public static void collectFilesInDir(File dir) { 
    TreeTraverser<File> traverser = Files.fileTreeTraverser(); 
    FluentIterable<File> filesInPostOrder = traverser.preOrderTraversal(dir); 
    for (File f: filesInPostOrder) 
     System.out.printf("File: %s\n", f.getPath()); 
} 

TreeTraverser también le permite a entre varios estilos de recorrido.