How can I read all files in a folder from Java?

To read all files in a folder using Java, you can use the java.io.File class (legacy) or the modern java.nio.file API (recommended). Below are detailed approaches with examples for both scenarios:

1. Using java.io.File (Legacy Approach)

Step 1: List All Files in a Directory

import java.io.File;

public class ReadFilesLegacy {
    public static void main(String[] args) {
        File folder = new File("path/to/directory");

        // Check if the path is a valid directory
        if (!folder.isDirectory()) {
            System.out.println("Invalid directory!");
            return;
        }

        // List all files in the directory
        File[] files = folder.listFiles();

        if (files != null) {
            for (File file : files) {
                if (file.isFile()) { // Skip subdirectories
                    System.out.println("File: " + file.getName());
                }
            }
        }
    }
}

Step 2: Read Content of Each File

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class ReadFilesLegacy {
    public static void main(String[] args) {
        File folder = new File("path/to/directory");

        if (!folder.isDirectory()) {
            System.out.println("Invalid directory!");
            return;
        }

        File[] files = folder.listFiles();

        if (files != null) {
            for (File file : files) {
                if (file.isFile()) {
                    try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
                        String line;
                        System.out.println("Content of " + file.getName() + ":");
                        while ((line = reader.readLine()) != null) {
                            System.out.println(line);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

2. Using java.nio.file (Modern API – Java 7+)

Step 1: List Files with Files.list()

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

public class ReadFilesNIO {
    public static void main(String[] args) {
        Path dir = Paths.get("path/to/directory");

        try (Stream<Path> paths = Files.list(dir)) {
            paths.filter(Files::isRegularFile) // Skip directories
                 .forEach(path -> System.out.println("File: " + path.getFileName()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Step 2: Read Files Recursively with Files.walk()

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

public class ReadFilesNIO {
    public static void main(String[] args) {
        Path dir = Paths.get("path/to/directory");

        try (Stream<Path> paths = Files.walk(dir)) {
            paths.filter(Files::isRegularFile)
                 .forEach(path -> {
                     try {
                         System.out.println("Reading: " + path);
                         String content = Files.readString(path); // Java 11+
                         System.out.println(content);
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. Read Files with Filters

Example: Read Only .txt Files

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

public class ReadFilesWithFilter {
    public static void main(String[] args) {
        Path dir = Paths.get("path/to/directory");

        try (Stream<Path> paths = Files.list(dir)) {
            paths.filter(Files::isRegularFile)
                 .filter(path -> path.toString().endsWith(".txt")) // Filter by extension
                 .forEach(path -> {
                     try {
                         System.out.println("Reading: " + path);
                         String content = Files.readString(path);
                         System.out.println(content);
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4. Read Files Line by Line (Java 8 Streams)

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

public class ReadFilesLineByLine {
    public static void main(String[] args) {
        Path dir = Paths.get("path/to/directory");

        try (Stream<Path> paths = Files.list(dir)) {
            paths.filter(Files::isRegularFile)
                 .forEach(path -> {
                     try (Stream<String> lines = Files.lines(path)) {
                         System.out.println("Lines in " + path.getFileName() + ":");
                         lines.forEach(System.out::println);
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Key Notes

1. Java Versions:

• Files.readString() requires Java 11+.
• Files.lines() and Streams API require Java 8+.

1. Error Handling:

• Always handle IOException and validate directory paths.
• Use try-with-resources to auto-close streams (e.g., Files.list()).

1. Performance:

• For large files, avoid Files.readString() or Files.readAllBytes() as they load the entire file into memory. Use BufferedReader or Files.lines() instead.

1. Recursive Traversal:

• Use Files.walk() to read files in subdirectories recursively.

Summary Table

Method/Class	Use Case	Example Code Snippet
java.io.File	Legacy code	File[] files = folder.listFiles();
Files.list()	List files in a directory	Files.list(dir).forEach(...);
Files.walk()	List files recursively	Files.walk(dir).filter(...);
Files.readString()	Read entire file as a string (Java 11)	String content = Files.readString(path);
Files.lines()	Read lines as a stream (Java 8+)	Files.lines(path).forEach(...);

By combining these methods, you can efficiently read all files in a directory and process their content in Java!