Count Files Recursively in Java

Omozegie AziegbeMay 7th, 2025Last Updated: May 7th, 2025

0 67 4 minutes read

Working with file systems is a vital part of many Java applications, and counting files recursively in a directory tree is a task you may encounter often. Java offers multiple methods to accomplish this, from the basic java.io.File API to the more robust and flexible java.nio.file package. This article will explore different techniques, from traditional File class recursion to modern Files.walk().

1. Overview

In many real-world applications, it becomes necessary to determine the total number of files within a directory and all of its nested subdirectories. This task might arise when monitoring disk usage, validating data integrity or generating file-related statistics. Unlike listing files in a single directory, this problem requires a recursive traversal of the directory tree structure to ensure no file, regardless of its depth is overlooked.

Java provides multiple APIs for working with file systems, including the legacy java.io.File class and the more powerful java.nio.file package. The challenge lies in visiting every folder and subfolder and keeping an accurate count as the traversal progresses.

An effective solution must therefore:

Navigate both top-level and nested directories.
Distinguish between files and folders.
Handle file system exceptions gracefully.
Scale well for directories containing thousands or millions of files.

1. Using Traditional Java IO (Recursive Method)

To count the total number of files (excluding directories) within a directory and all its subdirectories in Java, a recursive approach using File objects from java.io is often the most straightforward solution. This classic method involves traversing the directory tree recursively, visiting each folder and incrementing the count for every regular file encountered along the way.

import java.io.File;

public class JavaRecursiveFileCounter {

    public static int countFiles(File directory) {
        int count = 0;

        File[] files = directory.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    count++;
                } else if (file.isDirectory()) {
                    count += countFiles(file); // Recursive call
                }
            }
        }

        return count;
    }

    public static void main(String[] args) {
        File dir = new File("/Users/Downloads/wordpress"); // Change to your directory
        if (dir.exists() && dir.isDirectory()) {
            int fileCount = countFiles(dir);
            System.out.println("Total number of files: " + fileCount);
        } else {
            System.out.println("Invalid directory.");
        }
    }
}

This program begins by importing the java.io.File class, which provides access to file system paths and directory contents. The core functionality resides in the countFiles(File directory) method, which takes a File object representing a directory. It initializes a counter and retrieves the directory’s contents using listFiles(). If the result is not null, it loops through each File object: if the object is a regular file, it increments the counter; if it is a directory, it recursively calls countFiles() to count the files inside that subdirectory and adds the result to the total count.

In the main method, a File object is created pointing to the path /Users/Downloads/wordpress. The program checks whether the path exists and is a directory before invoking the countFiles() method and printing the total number of files found. If the path is invalid or not a directory, it prints an error message.

3. Using Java NIO (`Files.walk()`)

Java 7 introduced the NIO.2 API under java.nio.file, bringing file-walking capabilities that are useful in modern Java applications. One of its features is the Files.walk() method, which recursively traverses a directory tree and returns a Stream<Path> representing all files and subdirectories. When combined with the Stream API, this enables us to write concise and expressive code for tasks like counting all regular files within a directory and its nested structure.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileCounterNIO {

    public static long fileCount(Path dir) {
        long count = 0;
        try (Stream stream = Files.walk(dir)) {
            count = stream
                    .filter(p -> !Files.isDirectory(p)) // filter out directories
                    .count();
        } catch (IOException e) {
            System.err.println("Error reading directory: " + dir.toAbsolutePath());
        }
        return count;
    }

    public static void main(String[] args) {
        // change to a valid directory on your system
        Path dir = Paths.get("/Users/Downloads/wordpress");

        // Validate path
        if (!Files.exists(dir)) {
            System.out.println("The path " + dir.toAbsolutePath() + " does not exist.");
            return;
        }

        if (!Files.isDirectory(dir)) {
            System.out.println("The path " + dir.toAbsolutePath() + " is not a directory.");
            return;
        }

        // Count files
        long totalFiles = fileCount(dir);
        System.out.println("Total number of files: " + totalFiles);
    }
}

This program begins by validating the given directory path using Files.exists() and Files.isDirectory() to ensure that the provided path is valid and points to a directory.

The core logic is found in the fileCount() method, which calls Files.walk(dir) to create a stream of all paths in the directory tree. It then filters out any paths that represent directories, leaving only regular files, and finally uses .count() to return the total number of such files.

This approach is highly readable and concise, and leverages parallel processing capabilities if needed. It’s particularly useful for large directory structures, as it abstracts away the need for manual recursion and provides excellent performance through Java’s Stream API.

4. Conclusion

In this article, we explored various approaches to count the number of files in a directory and its subdirectories using Java. Starting with a traditional recursive method utilizing java.io.File, we examined how to traverse directories and accumulate file counts manually. We then demonstrated a more modern and efficient solution using Java NIO’s Files.walk() in combination with the Stream API, which offers cleaner syntax and better scalability, especially for large directory trees.

Both methods effectively solve the problem, but the NIO approach is generally preferred in production-grade applications due to its conciseness and performance advantages.