Lister tous les fichiers d'un répertoire de manière récursive avec Java

Question

J'ai cette fonction qui imprime le nom de tous les fichiers d'un répertoire de manière récursive. Le problème est que mon code est très lent car il doit accéder à un périphérique réseau distant à chaque itération.

J'ai l'intention de charger d'abord tous les fichiers du répertoire de manière récursive, puis de passer en revue tous les fichiers avec l'expression rationnelle pour filtrer tous les fichiers que je ne veux pas. Quelqu'un a-t-il une meilleure suggestion ?

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

C'est juste un test, plus tard je ne vais pas utiliser le code comme ça, à la place je vais ajouter le chemin et la date de modification de chaque fichier qui correspond à une regex avancée dans un tableau.

Answer 1

En supposant qu'il s'agisse d'un code de production réel que vous écrirez, je vous suggère d'utiliser la solution qui a déjà été trouvée pour ce type de problème Apache Commons IO et plus particulièrement FileUtils.listFiles() . Il gère les répertoires imbriqués, les filtres (basés sur le nom, le temps de modification, etc.).

Par exemple, pour votre regex :

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

Ceci recherchera de manière récursive les fichiers correspondant à l'option ^(.*?) regex, renvoyant les résultats sous forme de collection.

Il est important de noter que cela ne sera pas plus rapide que de développer votre propre code, cela revient à faire la même chose - parcourir un système de fichiers en Java est tout simplement lent. La différence est que la version Apache Commons ne contiendra pas de bogues.

Answer 2

Il s'agit d'une méthode récursive très simple pour obtenir tous les fichiers d'un Root donné.

Il utilise la classe 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 3

Avec Java 7, un moyen plus rapide de parcourir une arborescence de répertoires a été introduit avec la fonction Paths y Files fonctionnalité. Ils sont beaucoup plus rapides que les "anciens". File manière.

Ce serait le code pour parcourir et vérifier les noms de chemin avec une expression régulière :

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 4

Le moyen rapide d'obtenir le contenu d'un répertoire en utilisant 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 5

L'interface de Java pour lire le contenu des dossiers du système de fichiers n'est pas très performante (comme vous l'avez découvert). Le JDK 7 corrige ce problème avec une toute nouvelle interface pour ce genre de choses, qui devrait apporter des performances de niveau natif à ce genre d'opérations.

Le problème principal est que Java fait un appel système natif pour chaque fichier. Sur une interface à faible latence, ce n'est pas un gros problème, mais sur un réseau avec une latence même modérée, cela s'accumule. Si vous établissez le profil de votre algorithme ci-dessus, vous constaterez que la majeure partie du temps est consacrée à l'appel isDirectory() - c'est parce que vous devez effectuer un aller-retour pour chaque appel à isDirectory(). La plupart des systèmes d'exploitation modernes peuvent fournir ce type d'information lorsque la liste des fichiers/dossiers a été demandée à l'origine (par opposition à l'interrogation de chaque chemin de fichier individuel pour ses propriétés).

Si vous ne pouvez pas attendre le JDK7, une stratégie pour résoudre ce problème de latence consiste à opter pour le multithreading et à utiliser un ExecutorService avec un nombre maximum de threads pour effectuer votre récursion. Ce n'est pas génial (vous devez vous occuper du verrouillage de vos structures de données de sortie), mais ce sera beaucoup plus rapide que de le faire en monotâche.

Dans toutes vos discussions sur ce genre de choses, je vous recommande vivement de comparer avec ce que vous pourriez faire de mieux en utilisant du code natif (ou même un script en ligne de commande qui fait à peu près la même chose). Dire qu'il faut une heure pour traverser une structure de réseau ne veut pas dire grand-chose. Nous dire que vous pouvez le faire en natif en 7 secondes, mais que cela prend une heure en Java attirera l'attention des gens.