Список всех файлов из каталога рекурсивно с помощью Java

Предполагая, что вы будете писать реальный производственный код, я предлагаю использовать решение для подобных вещей, которое уже было решено — Предварительный ввод-вывод Apache Commons, в частности FileUtils.listFiles(). Он обрабатывает вложенные каталоги, фильтры (на основе имени, времени модификации и т. д.).

Например, для вашего регулярного выражения:

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

Это будет рекурсивно искать файлы, соответствующие регулярному выражению ^(.*?), возвращая результаты в виде коллекции.

Стоит отметить, что это будет не быстрее, чем накатывать ваш собственный код, это делает то же самое - траллинг файловой системы в Java просто медленный. Разница в том, что в версии Apache Commons не будет ошибок.

В Java 8 это однострочный файл через Files.find() с произвольно большой глубиной (например, 999) и BasicFileAttributes из isRegularFile()

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

Чтобы добавить больше фильтрации, улучшите лямбду, например, все файлы jpg, измененные за последние 24 часа:

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

Это очень простой рекурсивный метод получения всех файлов из заданного корня.

Он использует класс 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;
} 

В Java 7 был введен более быстрый способ обхода дерева каталогов с помощью функций Paths и Files. Они намного быстрее, чем "старый" File способ.

Это будет код для обхода и проверки имен путей с помощью регулярного выражения:

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

Быстрый способ получить содержимое каталога с помощью 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();

Интерфейс Java для чтения содержимого папок файловой системы не очень эффективен (как вы обнаружили). JDK 7 исправляет это с помощью совершенно нового интерфейса для такого рода вещей, который должен обеспечить производительность нативного уровня для таких операций.

Основная проблема заключается в том, что Java выполняет собственный системный вызов для каждого отдельного файла. На интерфейсе с малой задержкой это не так уж важно, но в сети даже с умеренной задержкой это действительно складывается. Если вы профилируете свой алгоритм выше, вы обнаружите, что основная часть времени тратится на надоедливый вызов isDirectory() - это потому, что вы выполняете круговое путешествие для каждого отдельного вызова isDirectory(). Большинство современных операционных систем могут предоставить такую ​​информацию, когда изначально запрашивался список файлов/папок (в отличие от запроса каждого отдельного пути к файлу для его свойств).

Если вы не можете дождаться JDK7, одной из стратегий устранения этой задержки является использование многопоточности и использование ExecutorService с максимальным числом потоков для выполнения вашей рекурсии. Это не очень хорошо (вам придется иметь дело с блокировкой ваших структур выходных данных), но это будет намного быстрее, чем выполнение этого однопоточного.

Во всех ваших обсуждениях такого рода вещей я настоятельно рекомендую вам сравнивать с лучшим, что вы могли бы сделать, используя собственный код (или даже сценарий командной строки, который делает примерно то же самое). Сказать, что прохождение сетевой структуры занимает час, на самом деле не так уж много значит. Сказав нам, что вы можете сделать это за 7 секунд, но на Java это займет час, вы привлечете внимание людей.

это будет работать нормально... и рекурсивно

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

Мне лично нравится эта версия FileUtils. Вот пример, который находит все файлы mp3 или flac в каталоге или любом из его подкаталогов:

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

Это будет работать нормально

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

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

    }

}

такое ощущение, что глупо обращаться к файловой системе и получать содержимое для каждого подкаталога вместо того, чтобы получать все сразу.

Ваше чувство ошибочно. Так работают файловые системы. Нет более быстрого способа (за исключением случаев, когда вам нужно делать это повторно или для разных шаблонов, вы можете кэшировать все пути к файлам в памяти, но тогда вам придется иметь дело с аннулированием кеша, т.е. что происходит, когда файлы добавляются/удаляются/переименовываются во время приложение работает).

Просто чтобы вы знали, что isDirectory() — довольно медленный метод. Я нахожу это довольно медленным в моем файловом браузере. Я буду искать библиотеку, чтобы заменить ее собственным кодом.

Более эффективный способ, который я нашел для работы с миллионами папок и файлов, — это захватить список каталогов с помощью команды DOS в каком-то файле и проанализировать его. После того, как вы проанализировали данные, вы можете провести анализ и вычислить статистику.

В Guava вам не нужно ждать, пока вам вернут коллекцию, но вы можете фактически перебирать файлы. Легко представить интерфейс IDoSomethingWithThisFile в сигнатуре функции ниже:

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 также позволяет между различными стилями обхода.

Еще один оптимизированный код

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

Еще один пример вывода списка файлов и каталогов с использованием 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");
        }
}