Listen Sie alle Dateien aus einem Verzeichnis rekursiv mit Java auf

Ich habe diese Funktion, die den Namen aller Dateien in einem Verzeichnis rekursiv druckt. Das Problem ist, dass mein Code sehr langsam ist, da er bei jeder Iteration auf ein Remote-Netzwerkgerät zugreifen muss.

Mein Plan ist es, zuerst alle Dateien rekursiv aus dem Verzeichnis zu laden und danach alle Dateien mit dem regulären Ausdruck durchzugehen, um alle Dateien herauszufiltern, die ich nicht möchte. Hat jemand einen besseren Vorschlag?

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

Dies ist nur ein Test später. Ich werde den Code nicht so verwenden, sondern den Pfad und das Änderungsdatum jeder Datei hinzufügen, die einem erweiterten regulären Ausdruck zu einem Array entspricht.

Angenommen, dies ist der tatsächliche Produktionscode, den Sie schreiben, dann schlage ich vor, die Lösung für diese Art von Dingen zu verwenden, die bereits gelöst wurden - speziell Apache Commons IOFileUtils.listFiles() . Es behandelt verschachtelte Verzeichnisse, Filter (basierend auf Name, Änderungszeit usw.).

Zum Beispiel für Ihre Regex:

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

Dadurch wird rekursiv nach Dateien gesucht, die dem ^(.*?)regulären Ausdruck entsprechen, und die Ergebnisse werden als Sammlung zurückgegeben.

Es ist erwähnenswert, dass dies nicht schneller ist als das Rollen Ihres eigenen Codes. Es macht dasselbe - das Durchsuchen eines Dateisystems in Java ist nur langsam. Der Unterschied ist, dass die Apache Commons-Version keine Fehler enthält.

In Java 8 handelt es sich um einen 1-Liner-Via Files.find()mit einer beliebig großen Tiefe (z. B. 999) und BasicFileAttributesvonisRegularFile()

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

Um weitere Filter hinzuzufügen, verbessern Sie das Lambda, z. B. alle in den letzten 24 Stunden geänderten JPG-Dateien:

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

Dies ist eine sehr einfache rekursive Methode, um alle Dateien von einem bestimmten Stamm abzurufen.

Es verwendet die Java 7 NIO Path-Klasse.

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

Mit Java 7 wurde eine schnellere Möglichkeit zum Durchlaufen eines Verzeichnisbaums mit der Pathsund Files-Funktionalität eingeführt. Sie sind viel schneller als der "alte" FileWeg.

Dies wäre der Code zum Durchlaufen und Überprüfen der Pfadnamen mit einem regulären Ausdruck:

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

Der schnelle Weg, um den Inhalt eines Verzeichnisses mit Java 7 NIO abzurufen:

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

Die Java-Oberfläche zum Lesen von Ordnerinhalten im Dateisystem ist nicht sehr leistungsfähig (wie Sie festgestellt haben). JDK 7 behebt dieses Problem mit einer völlig neuen Schnittstelle für diese Art von Dingen, die die Leistung auf nativer Ebene für diese Art von Vorgängen verbessern soll.

Das Hauptproblem besteht darin, dass Java für jede einzelne Datei einen nativen Systemaufruf ausführt. Auf einer Schnittstelle mit geringer Latenz ist dies keine große Sache - aber in einem Netzwerk mit selbst mäßiger Latenz summiert sich das wirklich. Wenn Sie Ihren Algorithmus oben profilieren, werden Sie feststellen, dass der Großteil der Zeit im lästigen Aufruf von isDirectory () verbracht wird. Dies liegt daran, dass Sie für jeden einzelnen Aufruf von isDirectory () einen Roundtrip durchführen. Die meisten modernen Betriebssysteme können diese Art von Informationen bereitstellen, wenn die Liste der Dateien / Ordner ursprünglich angefordert wurde (anstatt jeden einzelnen Dateipfad nach seinen Eigenschaften abzufragen).

Wenn Sie nicht auf JDK7 warten können, besteht eine Strategie zur Behebung dieser Latenz darin, Multithreading zu verwenden und einen ExecutorService mit einer maximalen Anzahl von Threads zu verwenden, um Ihre Rekursion durchzuführen. Es ist nicht großartig (Sie müssen sich mit dem Sperren Ihrer Ausgabedatenstrukturen befassen), aber es wird verdammt viel schneller sein als dieses einzelne Threaded.

In all Ihren Diskussionen über diese Art von Dingen empfehle ich Ihnen dringend, sich mit dem Besten zu vergleichen, das Sie mit nativem Code (oder sogar einem Befehlszeilenskript, das ungefähr dasselbe tut) tun können. Zu sagen, dass das Durchqueren einer Netzwerkstruktur eine Stunde dauert, bedeutet nicht wirklich viel. Wenn Sie uns sagen, dass Sie es in 7 Sekunden nativ machen können, aber in Java dauert es eine Stunde, wird die Aufmerksamkeit der Leute auf sich gezogen.

Dies wird gut funktionieren ... und es ist rekursiv

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

Ich persönlich mag diese Version von FileUtils. Hier ist ein Beispiel, das alle MP3s oder Flacs in einem Verzeichnis oder einem seiner Unterverzeichnisse findet:

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

Dies wird gut funktionieren

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

Diese Funktion listet wahrscheinlich den gesamten Dateinamen und den Pfad aus dem Verzeichnis und den Unterverzeichnissen auf.

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

    }

}

Es fühlt sich dumm an, auf das Dateisystem zuzugreifen und den Inhalt für jedes Unterverzeichnis abzurufen, anstatt alles auf einmal abzurufen.

Dein Gefühl ist falsch. So funktionieren Dateisysteme. Es gibt keinen schnelleren Weg (außer wenn Sie dies wiederholt oder für verschiedene Muster tun müssen, können Sie alle Dateipfade im Speicher zwischenspeichern, aber dann müssen Sie sich mit der Ungültigmachung des Caches befassen, dh was passiert, wenn Dateien hinzugefügt / entfernt / umbenannt werden die App läuft).

Nur damit Sie wissen, dass isDirectory () eine ziemlich langsame Methode ist. Ich finde es ziemlich langsam in meinem Dateibrowser. Ich werde in eine Bibliothek schauen, um sie durch nativen Code zu ersetzen.

Der effizientere Weg, mit Millionen von Ordnern und Dateien umzugehen, besteht darin, die Verzeichnisliste mit dem DOS-Befehl in einer Datei zu erfassen und zu analysieren. Sobald Sie die Daten analysiert haben, können Sie Analysen durchführen und Statistiken berechnen.

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

In Guava müssen Sie nicht auf die Rückgabe einer Sammlung warten, sondern können die Dateien tatsächlich durchlaufen. Es ist leicht, sich eine IDoSomethingWithThisFileSchnittstelle in der Signatur der folgenden Funktion vorzustellen :

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

Mit TreeTraverser können Sie auch zwischen verschiedenen Durchlaufstilen wechseln .

Java 8

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

        Path start = Paths.get("C:\\data\\");
        try (Stream<Path> stream = Files.walk(start, Integer.MAX_VALUE)) {
            List<String> collect = stream
                .map(String::valueOf)
                .sorted()
                .collect(Collectors.toList());

            collect.forEach(System.out::println);
        }


    }

public class GetFilesRecursive {
    public static List <String> getFilesRecursively(File dir){
        List <String> ls = new ArrayList<String>();
        for (File fObj : dir.listFiles()) {
            if(fObj.isDirectory()) {
                ls.add(String.valueOf(fObj));
                ls.addAll(getFilesRecursively(fObj));               
            } else {
                ls.add(String.valueOf(fObj));       
            }
        }

        return ls;
    }
    public static List <String> getListOfFiles(String fullPathDir) {
        List <String> ls = new ArrayList<String> ();
        File f = new File(fullPathDir);
        if (f.exists()) {
            if(f.isDirectory()) {
                ls.add(String.valueOf(f));
                ls.addAll(getFilesRecursively(f));
            }
        } else {
            ls.add(fullPathDir);
        }
        return ls;
    }

    public static void main(String[] args) {
        List <String> ls = getListOfFiles("/Users/srinivasab/Documents");
        for (String file:ls) {
            System.out.println(file);
        }
        System.out.println(ls.size());
    }
}

Ein weiterer optimierter Code

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class GetFilesRecursive {
    public static List <String> getFilesRecursively(File dir){
        List <String> ls = new ArrayList<String>();
        if (dir.isDirectory())
            for (File fObj : dir.listFiles()) {
                if(fObj.isDirectory()) {
                    ls.add(String.valueOf(fObj));
                    ls.addAll(getFilesRecursively(fObj));               
                } else {
                    ls.add(String.valueOf(fObj));       
                }
            }
        else
            ls.add(String.valueOf(dir));

        return ls;
    }

    public static void main(String[] args) {
        List <String> ls = getFilesRecursively(new File("/Users/srinivasab/Documents"));
        for (String file:ls) {
            System.out.println(file);
        }
        System.out.println(ls.size());
    }
}

Ein weiteres Beispiel für das Auflisten von Dateien und Verzeichnissen mit Java 8 filter

public static void main(String[] args) {

System.out.println("Files!!");
        try {
            Files.walk(Paths.get("."))
                    .filter(Files::isRegularFile)
                    .filter(c ->
                            c.getFileName().toString().substring(c.getFileName().toString().length()-4).contains(".jpg")
                            ||
                            c.getFileName().toString().substring(c.getFileName().toString().length()-5).contains(".jpeg")
                    )
                    .forEach(System.out::println);

        } catch (IOException e) {
        System.out.println("No jpeg or jpg files");
        }

        System.out.println("\nDirectories!!\n");
        try {
            Files.walk(Paths.get("."))
                    .filter(Files::isDirectory)
                    .forEach(System.out::println);

        } catch (IOException e) {
            System.out.println("No Jpeg files");
        }
}