Java 8 provides a nice stream to process all files in a tree.

try (Stream<Path> stream = Files.walk(Paths.get(path))) {
    stream.filter(Files::isRegularFile)
          .forEach(System.out::println);
}

This provides a natural way to traverse files. Since it's a stream you can do all nice stream operations on the result such as limit, grouping, mapping, exit early etc.

UPDATE: I might point out there is also Files.find which takes a BiPredicate that could be more efficient if you need to check file attributes.

Files.find(Paths.get(path),
           Integer.MAX_VALUE,
           (filePath, fileAttr) -> fileAttr.isRegularFile())
        .forEach(System.out::println);

Note that while the JavaDoc eludes that this method could be more efficient than Files.walk it is effectively identical, the difference in performance can be observed if you are also retrieving file attributes within your filter. In the end, if you need to filter on attributes use Files.find, otherwise use Files.walk, mostly because there are overloads and it's more convenient.

TESTS: As requested I've provided a performance comparison of many of the answers. Check out the Github project which contains results and a test case.

Assuming this is actual production code you'll be writing, then I suggest using the solution to this sort of thing that's already been solved - Apache Commons IO, specifically FileUtils.listFiles(). It handles nested directories, filters (based on name, modification time, etc).

For example, for your regex:

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

This will recursively search for files matching the ^(.*?) regex, returning the results as a collection.

It's worth noting that this will be no faster than rolling your own code, it's doing the same thing - trawling a filesystem in Java is just slow. The difference is, the Apache Commons version will have no bugs in it.

Recursively Listing All Files Under a Directory in Java Recursively listing all files within a directory and its subdirectories is a common task in Java programming. This process involves navigating through each folder and its nested folders to retrieve and display all the files contained within. Understanding how to implement this efficiently can aid in tasks such as file management, data processing, and building applications that require file system interactions. Steps to Recursively List All Files 1. Choose the Right Approach In Java, there are multiple ways to traverse directories recursively. You can use traditional recursion with the File class or leverage the more modern java.nio.file package introduced in Java 7. 2. Using the File Class with Recursion The File class provides methods to interact with the file system. Here's how you can use it to list all files recursively: Example Code import java.io.File; public class FileLister { public static void main(String[] args) { String directoryPath = "C:\\Path\\To\\Your\\Directory"; File directory = new File(directoryPath); listFilesRecursively(directory); } public static void listFilesRecursively(File dir) { if (dir.isDirectory()) { File[] files = dir.listFiles(); if (files != null) { // Check for permission issues for (File file : files) { if (file.isDirectory()) { listFilesRecursively(file); // Recursive call for subdirectories } else { System.out.println(file.getAbsolutePath()); } } } } else { System.out.println(dir.getAbsolutePath()); } } }