Java BufferedWriter Data Loss — Flush and Close 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.*;
import java.nio.file.*;
import java.util.Scanner;

public class ScannerVsBufferedReaderBenchmark {

    public static void main(String[] args) throws IOException {
        Path tempFile = Files.createTempFile("bench", ".txt");
        // Write 50,000 lines
        try (BufferedWriter w = Files.newBufferedWriter(tempFile)) {
            for (int i = 0; i < 50_000; i++) {
                w.write("Line number " + i);
                w.newLine();
            }
        }

        // BufferedReader
        long startB = System.nanoTime();
        try (BufferedReader reader = Files.newBufferedReader(tempFile)) {
            String line;
            while ((line = reader.readLine()) != null) {
                // Simulate basic processing
                if (line.startsWith("Line")) { }
            }
        }
        long bufferedTime = System.nanoTime() - startB;

        // Scanner with nextLine
        long startS = System.nanoTime();
        try (Scanner scanner = new Scanner(tempFile.toFile(), "UTF-8")) {
            while (scanner.hasNextLine()) {
                String line = scanner.nextLine();
                if (line.startsWith("Line")) { }
            }
        }
        long scannerTime = System.nanoTime() - startS;

        System.out.println("BufferedReader: " + bufferedTime / 1_000_000 + " ms");
        System.out.println("Scanner:        " + scannerTime / 1_000_000 + " ms");
        System.out.println("Scanner is ~" + (scannerTime / Math.max(bufferedTime, 1)) + "x slower");

        Files.deleteIfExists(tempFile);
    }
}

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.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;

public class MethodReferenceDemo {

    public static void main(String[] args) throws IOException {
        Path tempFile = Files.createTempFile("methods", ".txt");

        // Demonstrate key methods
        try (BufferedWriter writer = Files.newBufferedWriter(tempFile, StandardCharsets.UTF_8)) {
            // write(int) — single character
            writer.write('H');
            writer.write('i');
            writer.newLine();

            // write(String)
            writer.write("Hello, Reader!");
            writer.newLine();

            // write(char[]) + flush
            char[] chars = { 'B', 'u', 'f', 'f', 'e', 'r' };
            writer.write(chars, 0, chars.length);
            writer.newLine();
            writer.flush(); // force to disk
        }

        // Read back with various methods
        try (BufferedReader reader = Files.newBufferedReader(tempFile, StandardCharsets.UTF_8)) {
            // read() single char
            int single = reader.read();
            System.out.println("First char (int): " + single + " -> " + (char) single);

            // readLine()
            String line = reader.readLine();
            System.out.println("First line: " + line);

            // read(char[], off, len)
            char[] buffer = new char[20];
            int charsRead = reader.read(buffer, 0, buffer.length);
            System.out.print("Bulk read (" + charsRead + " chars): ");
            for (int i = 0; i < charsRead; i++) System.out.print(buffer[i]);
            System.out.println();
        }

        Files.deleteIfExists(tempFile);
    }
}

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);
    }
}

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

public class CharsetConversionUtility {

    public static void convertFileCharset(Path sourcePath, Charset sourceCharset,
                                           Path destPath, Charset destCharset)
            throws IOException {

        try (
            BufferedReader reader = Files.newBufferedReader(sourcePath, sourceCharset);
            BufferedWriter writer = Files.newBufferedWriter(destPath, destCharset,
                    StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Path sourceFile = Files.createTempFile("source_", ".txt");
        Files.writeString(sourceFile, "Olá, mundo! Müller Straße 123\n", StandardCharsets.ISO_8859_1);

        Path destFile = Files.createTempFile("dest_", ".txt");

        // Convert from ISO-8859-1 to UTF-8
        convertFileCharset(sourceFile, StandardCharsets.ISO_8859_1,
                           destFile, StandardCharsets.UTF_8);

        System.out.println("Original file (ISO-8859-1) bytes: ");
        byte[] originalBytes = Files.readAllBytes(sourceFile);
        for (byte b : originalBytes) System.out.printf("%02x ", b);
        System.out.println();

        System.out.println("Converted file (UTF-8) bytes: ");
        byte[] convertedBytes = Files.readAllBytes(destFile);
        for (byte b : convertedBytes) System.out.printf("%02x ", b);
        System.out.println();

        // Verify content
        System.out.println("Original content: " + Files.readString(sourceFile, StandardCharsets.ISO_8859_1));
        System.out.println("Converted content: " + Files.readString(destFile, StandardCharsets.UTF_8));

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

// io.thecodeforge — java tutorial

import java.io.*;

public class FlushOnCrash {
    public static void main(String[] args) throws IOException {
        BufferedWriter writer = new BufferedWriter(new FileWriter("critical.log"));
        try {
            writer.write("Payment processed: $12,000");
            writer.flush();  // Force to disk NOW
            // Simulated crash: if we skip flush, this data is lost
            if (true) throw new RuntimeException("System failure");
        } finally {
            writer.close();
        }
    }
}

// io.thecodeforge — java tutorial

import java.io.*;

public class CustomBufferSize {
    public static void main(String[] args) throws IOException {
        // Large buffer for big file writes
        try (BufferedWriter writer = new BufferedWriter(
                new FileWriter("bigdata.csv"), 65536)) {
            for (int i = 0; i < 1_000_000; i++) {
                writer.write("line," + i + "\n");
            }
        }
        // Small buffer for bursty writes
        try (BufferedWriter writer = new BufferedWriter(
                new FileWriter("events.log"), 1024)) {
            writer.write("quick event");
            writer.flush();
        }
    }
}

// io.thecodeforge — java tutorial
import java.io.*;

public class FileCopyBuffered {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        } // both flushed and closed automatically
    }
}

// io.thecodeforge — java tutorial
import java.io.*;

public class BufferedDecorator {
    public static void main(String[] args) throws IOException {
        // FileReader: raw file access
        // BufferedReader: adds buffering decorator
        Reader raw = new FileReader("data.txt");
        Reader buffered = new BufferedReader(raw);
        
        int ch;
        while ((ch = buffered.read()) != -1) {
            System.out.print((char) ch);
        }
        buffered.close(); // closes raw too
    }
}