Java BufferedReader and BufferedWriter Explained — Performance, Patterns and Pitfalls

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class BufferedVsUnbufferedDemo {

    // Write a temp file we can use for both read experiments
    private static Path createSampleFile() throws IOException {
        Path tempFile = Files.createTempFile("forge_demo", ".txt");
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile.toFile()))) {
            for (int lineNumber = 1; lineNumber <= 5000; lineNumber++) {
                writer.write("Line " + lineNumber + ": The quick brown fox jumps over the lazy dog.");
                writer.newLine(); // OS-appropriate line separator — not hardcoded \n
            }
        } // BufferedWriter flushes and closes automatically here (try-with-resources)
        return tempFile;
    }

    public static void main(String[] args) throws IOException {
        Path sampleFile = createSampleFile();

        // --- UNBUFFERED READ ---
        long startUnbuffered = System.currentTimeMillis();
        int totalCharsUnbuffered = 0;
        try (FileReader rawReader = new FileReader(sampleFile.toFile())) {
            int character;
            while ((character = rawReader.read()) != -1) { // Each call hits the OS
                totalCharsUnbuffered++;
            }
        }
        long unbufferedTime = System.currentTimeMillis() - startUnbuffered;

        // --- BUFFERED READ ---
        long startBuffered = System.currentTimeMillis();
        int totalCharsBuffered = 0;
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader(sampleFile.toFile()))) {
            int character;
            while ((character = bufferedReader.read()) != -1) { // Served from in-memory buffer
                totalCharsBuffered++;
            }
        }
        long bufferedTime = System.currentTimeMillis() - startBuffered;

        System.out.println("=== I/O Performance Comparison ===");
        System.out.println("Characters read (unbuffered): " + totalCharsUnbuffered);
        System.out.println("Unbuffered time: " + unbufferedTime + " ms");
        System.out.println("Characters read (buffered):   " + totalCharsBuffered);
        System.out.println("Buffered time:   " + bufferedTime + " ms");
        System.out.println("Speedup factor:  ~" + (unbufferedTime > 0 ? unbufferedTime / Math.max(bufferedTime, 1) : "N/A") + "x");

        Files.deleteIfExists(sampleFile); // Clean up after ourselves
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;

// Simulates processing a CSV file of employee records
public class CsvFileProcessor {

    record Employee(String name, String department, int salary) {}

    public static List<Employee> loadEmployeesFromCsv(Path csvFilePath) throws IOException {
        List<Employee> employees = new ArrayList<>();

        // Files.newBufferedReader uses UTF-8 by default and is the modern idiomatic approach
        try (BufferedReader reader = Files.newBufferedReader(csvFilePath)) {

            String headerLine = reader.readLine(); // Skip the header row
            if (headerLine == null) {
                System.out.println("Warning: CSV file is empty — " + csvFilePath);
                return employees;
            }

            String line;
            int lineNumber = 2; // Start at 2 since we already read line 1

            while ((line = reader.readLine()) != null) { // null signals end-of-file
                line = line.strip(); // Remove any accidental leading/trailing whitespace

                if (line.isEmpty()) {
                    lineNumber++;
                    continue; // Skip blank lines gracefully
                }

                String[] fields = line.split(",");

                if (fields.length != 3) {
                    System.out.printf("Skipping malformed line %d: %s%n", lineNumber, line);
                    lineNumber++;
                    continue;
                }

                try {
                    String employeeName = fields[0].strip();
                    String department   = fields[1].strip();
                    int salary          = Integer.parseInt(fields[2].strip());
                    employees.add(new Employee(employeeName, department, salary));
                } catch (NumberFormatException e) {
                    System.out.printf("Invalid salary on line %d, skipping: %s%n", lineNumber, line);
                }

                lineNumber++;
            }
        } // Reader automatically closed here — even if an exception is thrown above

        return employees;
    }

    public static void main(String[] args) throws IOException {
        // Create a sample CSV file to process
        Path csvFile = Files.createTempFile("employees", ".csv");
        Files.writeString(csvFile,
            "name,department,salary\n" +
            "Alice Nguyen,Engineering,95000\n" +
            "Bob Patel,Marketing,72000\n" +
            "Carol Smith,Engineering,102000\n" +
            "",  // trailing newline — realistic scenario
            java.nio.charset.StandardCharsets.UTF_8
        );

        List<Employee> employees = loadEmployeesFromCsv(csvFile);

        System.out.println("=== Loaded Employees ===");
        for (Employee emp : employees) {
            System.out.printf("%-15s | %-12s | $%,d%n",
                emp.name(), emp.department(), emp.salary());
        }
        System.out.println("Total records: " + employees.size());

        Files.deleteIfExists(csvFile);
    }
}

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

// Simulates an application-level log writer that appends entries to a log file
public class ApplicationLogWriter {

    private static final DateTimeFormatter LOG_TIMESTAMP_FORMAT =
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    enum LogLevel { INFO, WARN, ERROR }

    // Opens the writer in APPEND mode — existing content is preserved
    public static void writeLogEntries(Path logFilePath, String[] messages, LogLevel[] levels)
            throws IOException {

        // StandardOpenOption.APPEND means we add to the file rather than overwriting it
        // StandardOpenOption.CREATE means the file is created if it doesn't exist yet
        try (BufferedWriter logWriter = Files.newBufferedWriter(
                logFilePath,
                java.nio.charset.StandardCharsets.UTF_8,
                StandardOpenOption.CREATE,
                StandardOpenOption.APPEND)) {

            for (int i = 0; i < messages.length; i++) {
                String timestamp = LocalDateTime.now().format(LOG_TIMESTAMP_FORMAT);
                LogLevel level   = (i < levels.length) ? levels[i] : LogLevel.INFO;

                // Build a properly formatted log line
                String logEntry = String.format("[%s] [%-5s] %s", timestamp, level, messages[i]);

                logWriter.write(logEntry);  // Write the log message
                logWriter.newLine();        // Add platform-correct line ending

                // For ERROR entries, flush immediately so monitoring tools see them instantly
                if (level == LogLevel.ERROR) {
                    logWriter.flush(); // Force to disk right now — don't wait for buffer to fill
                    System.out.println("ALERT: Error flushed immediately to log.");
                }
            }

        } // Final flush + close happens here automatically
    }

    public static void main(String[] args) throws IOException {
        Path logFile = Paths.get(System.getProperty("java.io.tmpdir"), "app_forge.log");

        String[] logMessages = {
            "Application started successfully",
            "Processing batch job ID: 4821",
            "Database connection pool exhausted — retrying in 5s",
            "Batch job ID: 4821 completed. Records processed: 1,204"
        };

        LogLevel[] logLevels = {
            LogLevel.INFO,
            LogLevel.INFO,
            LogLevel.ERROR,
            LogLevel.INFO
        };

        writeLogEntries(logFile, logMessages, logLevels);

        // Read back what we wrote to confirm it looks right
        System.out.println("\n=== Log File Contents ===");
        Files.lines(logFile).forEach(System.out::println);

        Files.deleteIfExists(logFile);
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;

// A real-world text file copy utility that normalises whitespace during transfer
public class TextFileCopyUtility {

    record CopyResult(int linesCopied, int linesSkipped, long bytesWritten) {}

    /**
     * Copies a text file from source to destination, trimming trailing whitespace
     * from each line. Empty lines in the original are preserved as empty lines.
     * Returns a summary of what happened.
     */
    public static CopyResult copyAndNormalise(Path sourcePath, Path destinationPath)
            throws IOException {

        int linesCopied  = 0;
        int linesSkipped = 0;

        // Both reader and writer declared in the same try-with-resources block
        // Java guarantees both will be closed even if an exception occurs mid-copy
        try (
            BufferedReader sourceReader = Files.newBufferedReader(sourcePath, StandardCharsets.UTF_8);
            BufferedWriter destinationWriter = Files.newBufferedWriter(
                destinationPath,
                StandardCharsets.UTF_8,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING) // Overwrite if file already exists
        ) {
            String rawLine;

            while ((rawLine = sourceReader.readLine()) != null) {
                String normalisedLine = rawLine.stripTrailing(); // Remove trailing spaces/tabs

                if (normalisedLine.length() < rawLine.length()) {
                    linesSkipped++; // Count lines that had trailing whitespace cleaned up
                }

                destinationWriter.write(normalisedLine); // Write normalised content
                destinationWriter.newLine();              // Always use platform line separator
                linesCopied++;
            }

            // destinationWriter.flush() is called by close() via try-with-resources
            // No need to call it manually here
        }

        long bytesWritten = Files.size(destinationPath);
        return new CopyResult(linesCopied, linesSkipped, bytesWritten);
    }

    public static void main(String[] args) throws IOException {
        // Build a source file with intentional trailing whitespace on some lines
        Path sourceFile = Files.createTempFile("source_", ".txt");
        Files.writeString(sourceFile,
            "Product Report — Q4 2024   \n" +    // trailing spaces
            "\n" +                               // blank line
            "Widget A: 1,240 units sold   \t\n" + // trailing tab + spaces
            "Widget B: 980 units sold\n" +        // clean line
            "Widget C: 3,100 units sold  \n",    // trailing spaces
            StandardCharsets.UTF_8
        );

        Path destinationFile = Files.createTempFile("normalised_", ".txt");

        CopyResult result = copyAndNormalise(sourceFile, destinationFile);

        System.out.println("=== Copy Utility Results ===");
        System.out.println("Lines copied:           " + result.linesCopied());
        System.out.println("Lines normalised:       " + result.linesSkipped());
        System.out.println("Bytes written to disk:  " + result.bytesWritten());

        System.out.println("\n=== Destination File Contents ===");
        Files.lines(destinationFile, StandardCharsets.UTF_8)
             .forEach(line -> System.out.println("[" + line + "]"));

        Files.deleteIfExists(sourceFile);
        Files.deleteIfExists(destinationFile);
    }
}