How to list all files in a directory in Java

In Java, there are many ways to list all files and folders in a directory. You can use either the Files.walk(), Files.list(), or File.listFiles() method to iterate over all the files available in a certain directory.

Files.walk() Method

The Files.walk() is another static method from the NIO API to list all files and sub-directories in a directory. This method throws a NoSuchFileException exception if the folder doesn't exist.

Here is an example that lists all files and sub-directories in a directory called ~/java-runner:

try (Stream<Path> paths = Files.walk(Paths.get("~/java-runner"))) {
    // print all files and folders
    paths.forEach(System.out::println);
} catch (IOException ex) {
    ex.printStackTrace();
}

Since it returns a Stream object, you can filter out nested directories and only list regular files like below:

try (Stream<Path> paths = Files.walk(Paths.get("~/java-runner"))) {
    // filer out sub-directories
    List<String> files = paths.filter(x -> Files.isRegularFile(x))
            .map(Path::toString)
            .collect(Collectors.toList());

    // print all files
    files.forEach(System.out::println);

} catch (IOException ex) {
    ex.printStackTrace();
}

Similarly, you can also list only sub-directories by filtering out all regular files:

try (Stream<Path> paths = Files.walk(Paths.get("~/java-runner"))) {
    // filer out regular files
    List<String> folders = paths.filter(x -> Files.isDirectory(x))
            .map(Path::toString)
            .collect(Collectors.toList());

    // print all folders
    folders.forEach(System.out::println);

} catch (IOException ex) {
    ex.printStackTrace();
}

Here is another example that lists all .java files using Files.walk():

try (Stream<Path> paths = Files.walk(Paths.get("~/java-runner"))) {
    // keep only `.java` files
    List<String> javaFiles = paths.map(Path::toString)
            .filter(x -> x.endsWith(".java"))
            .collect(Collectors.toList());

    // print all files
    javaFiles.forEach(System.out::println);

} catch (IOException ex) {
    ex.printStackTrace();
}

By default, the Stream object returned by Files.walk() recursively walks through the file tree up to an n-level (all nested files and folders). However, you can pass another parameter to Files.walk() to limit the maximum number of directory levels to visit.

Here is an example that restricts the directory level to a top-level folder only (level 1):

try (Stream<Path> paths = Files.walk(Paths.get("~/java-runner"), 1)) {
    // print all files and folders in the current folder
    paths.forEach(System.out::println);
} catch (IOException ex) {
    ex.printStackTrace();
}

In the above code, the second parameter of Fils.walk() is the maximum number of levels of directories to visit. A value of 0 means that only the starting file is visited, unless denied by the security manager. A value of Integer.MAX_VALUE indicatea that all levels should be traversed.

Files.list() Method

The Files.list() static method from NIO API provides the simplest way to list the names of all files and folders in a given directory:

try (Stream<Path> paths = Files.list(Paths.get("~/java-runner"))) {
    // print all files and folders
    paths.forEach(System.out::println);
} catch (IOException ex) {
    ex.printStackTrace();
}

The Files.list() method returns a lazily populated Stream of entries in the directory. So you can apply all the above filters for Files.walk() on the stream.

File.listFiles() Method

In old Java versions (JDK 6 and below), the File.listFiles() method is available to list all files and nested folders in a directory.

Here is an example that uses File.listFiles() to print all files and folders in the given directory:

File folder = new File("~/java-runner");

// list all files
for (File file : folder.listFiles()) {
    System.out.println(file);
}

To list only regular files, do the following:

File folder = new File("~/java-runner");

// list all regular files
for (File file : folder.listFiles()) {
    if (file.isFile()) {
        System.out.println(file);
    }
}

Similarly, to list only sub-folders, you can use the below code:

File folder = new File("~/java-runner");

// list all sub-directories
for (File file : folder.listFiles()) {
    if (file.isDirectory()) {
        System.out.println(file);
    }
}

To recursively list all files and folders, we can write a recursive function as follows:

public void listFilesRecursive(File folder) {
    for (final File file : folder.listFiles()) {
        if (file.isDirectory()) {
            // uncomment this to list folders too
            // System.out.println(file);
            listFilesRecursive(file);
        } else {
            System.out.println(file);
        }
    }
}

// list files recursively
File folder = new File("~/java-runner");
listFilesRecursive(folder);

Further Reading

You may be interested in other Java I/O articles:

• Reading and Writing Files in Java
• How to Read and Write Text Files in Java
• How to Read and Write Binary Files in Java
• Reading and Writing Files using Java NIO API
• How to read a file line by line in Java

✌️ Like this article? Follow me on Twitter and LinkedIn. You can also subscribe to RSS Feed.