Java File Handling Explained — Read, Write, and Manage Files Like a Pro

import java.io.File;
import java.time.Instant;

public class FileInspector {

    public static void main(String[] args) {
        // Represent a path — no file is opened yet, this is just a reference
        File configFile = new File("app-config.txt");

        // Check existence BEFORE attempting to read — avoids FileNotFoundException
        if (configFile.exists()) {
            System.out.println("File found: " + configFile.getAbsolutePath());
            System.out.println("Size: " + configFile.length() + " bytes");
            System.out.println("Readable: " + configFile.canRead());
            System.out.println("Writable: " + configFile.canWrite());
            System.out.println("Last modified: " +
                Instant.ofEpochMilli(configFile.lastModified()));
        } else {
            System.out.println("Config file not found. Creating it now...");

            try {
                // createNewFile() returns true if file was created, false if it already existed
                boolean wasCreated = configFile.createNewFile();
                System.out.println("File created: " + wasCreated);
            } catch (java.io.IOException e) {
                // IOException is thrown if the parent directory doesn't exist
                // or if you don't have write permission
                System.err.println("Could not create file: " + e.getMessage());
            }
        }

        // Demonstrate directory creation — mkdirs() creates the full path, not just one level
        File logDirectory = new File("logs/2024/january");
        if (!logDirectory.exists()) {
            boolean dirCreated = logDirectory.mkdirs(); // plural 'mkdirs' handles nested dirs
            System.out.println("Log directory created: " + dirCreated);
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class UserActivityLogger {

    private static final String LOG_FILE_PATH = "user-activity.log";
    private static final DateTimeFormatter TIMESTAMP_FORMAT =
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    // Logs a user action to a file — the second argument controls append vs overwrite
    public static void logAction(String username, String action) throws IOException {
        String timestamp = LocalDateTime.now().format(TIMESTAMP_FORMAT);
        String logEntry = String.format("[%s] USER=%s ACTION=%s%n",
            timestamp, username, action);

        // try-with-resources: the writer is GUARANTEED to close when this block exits
        // FileWriter(path, true) — the 'true' flag means APPEND, not overwrite
        try (BufferedWriter writer = new BufferedWriter(
                new FileWriter(LOG_FILE_PATH, true))) {

            writer.write(logEntry);
            // BufferedWriter batches writes — flush() forces the buffer to disk immediately
            // Not needed here because close() calls flush() automatically
        }
        // No need for finally { writer.close() } — try-with-resources handles it
    }

    public static void main(String[] args) throws IOException {
        logAction("alice", "LOGIN");
        logAction("alice", "VIEW_DASHBOARD");
        logAction("bob",   "LOGIN");
        logAction("alice", "LOGOUT");

        System.out.println("Activity log written to: " + LOG_FILE_PATH);
        System.out.println("Check the file to see the 4 entries.");
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Stream;

public class CsvReportParser {

    // --- APPROACH 1: BufferedReader — great when you need manual control per line ---
    public static void readWithBufferedReader(String filePath) throws IOException {
        System.out.println("=== BufferedReader Approach ===");

        try (BufferedReader reader = new BufferedReader(
                new FileReader(filePath, StandardCharsets.UTF_8))) { // Always specify charset!

            String currentLine;
            int lineNumber = 0;

            // readLine() returns null at end-of-file — that's your loop termination signal
            while ((currentLine = reader.readLine()) != null) {
                lineNumber++;
                if (lineNumber == 1) {
                    System.out.println("Header row: " + currentLine);
                    continue; // Skip the CSV header
                }
                String[] columns = currentLine.split(",");
                if (columns.length >= 3) {
                    System.out.printf("  Record: name=%-15s score=%s grade=%s%n",
                        columns[0].trim(), columns[1].trim(), columns[2].trim());
                }
            }
            System.out.println("Total data rows read: " + (lineNumber - 1));
        }
    }

    // --- APPROACH 2: Files.lines() — best for large files, uses a lazy stream ---
    public static long countHighScorers(String filePath, int minimumScore)
            throws IOException {
        Path csvPath = Paths.get(filePath);

        // Files.lines() does NOT load the whole file into memory at once
        // The try-with-resources is REQUIRED here — the stream holds an open file handle
        try (Stream<String> lineStream = Files.lines(csvPath, StandardCharsets.UTF_8)) {
            return lineStream
                .skip(1)  // skip the header row
                .map(line -> line.split(","))
                .filter(cols -> cols.length >= 2)
                .mapToInt(cols -> {
                    try { return Integer.parseInt(cols[1].trim()); }
                    catch (NumberFormatException e) { return 0; }
                })
                .filter(score -> score >= minimumScore)
                .count();
        }
    }

    // --- APPROACH 3: Files.readAllLines() — for small files where you want a List ---
    public static void readSmallConfigFile(String filePath) throws IOException {
        System.out.println("\n=== Files.readAllLines() Approach ===");
        Path configPath = Paths.get(filePath);

        // Loads ALL lines into memory — only use this for small files (< a few MB)
        List<String> allLines = Files.readAllLines(configPath, StandardCharsets.UTF_8);
        allLines.stream()
            .filter(line -> !line.startsWith("#")) // ignore comment lines
            .filter(line -> line.contains("="))
            .forEach(line -> System.out.println("  Config entry: " + line));
    }

    public static void main(String[] args) throws IOException {
        // To run this, create a file called 'students.csv' with the content:
        // name,score,grade
        // Alice,92,A
        // Bob,74,C
        // Charlie,88,B
        // Diana,95,A

        readWithBufferedReader("students.csv");

        long highScorers = countHighScorers("students.csv", 85);
        System.out.println("\nStudents scoring 85 or above: " + highScorers);
    }
}

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.List;

public class SafeConfigWriter {

    private static final Path CONFIG_PATH = Paths.get("application.properties");

    // SAFE write pattern: write to a temp file, then atomically rename
    // This means readers never see a partially-written config file
    public static void writeConfigSafely(List<String> configLines) throws IOException {
        // Create a temp file in the SAME directory — required for atomic move
        Path tempFile = Files.createTempFile(
            CONFIG_PATH.getParent(), // same directory as the real file
            ".app-config-",          // prefix
            ".tmp"                   // suffix
        );

        try {
            // Write all content to the temp file first
            // StandardOpenOption.WRITE + TRUNCATE_EXISTING is the default for Files.write()
            Files.write(tempFile, configLines, StandardCharsets.UTF_8);

            // ATOMIC_MOVE: on Linux/macOS this is a rename() syscall — instantaneous
            // REPLACE_EXISTING: overwrite the destination if it already exists
            Files.move(tempFile, CONFIG_PATH,
                StandardCopyOption.ATOMIC_MOVE,
                StandardCopyOption.REPLACE_EXISTING);

            System.out.println("Config written atomically to: " + CONFIG_PATH.toAbsolutePath());

        } catch (IOException writeError) {
            // If anything goes wrong, clean up the temp file
            Files.deleteIfExists(tempFile); // deleteIfExists won't throw if file is already gone
            throw writeError; // re-throw so the caller knows the write failed
        }
    }

    // Demonstrates other NIO.2 utilities
    public static void demonstrateCopyAndDelete() throws IOException {
        Path sourceFile = Paths.get("application.properties");
        Path backupFile = Paths.get("application.properties.bak");

        // Copy a file — REPLACE_EXISTING prevents CopyOption collision if backup exists
        if (Files.exists(sourceFile)) {
            Files.copy(sourceFile, backupFile, StandardCopyOption.REPLACE_EXISTING);
            System.out.println("Backup created: " + backupFile);
            System.out.println("Backup size: " + Files.size(backupFile) + " bytes");
        }

        // Files.readString() — Java 11+, the most concise way to read a small file
        if (Files.exists(sourceFile)) {
            String content = Files.readString(sourceFile, StandardCharsets.UTF_8);
            System.out.println("\nConfig content:\n" + content);
        }
    }

    public static void main(String[] args) throws IOException {
        List<String> configEntries = List.of(
            "# Application Configuration",
            "app.name=TheCodeForge",
            "app.version=2.1.0",
            "db.host=localhost",
            "db.port=5432",
            "cache.enabled=true"
        );

        writeConfigSafely(configEntries);
        demonstrateCopyAndDelete();
    }
}