Java FileWriter overwrites logs on restart - append mode

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class WriteUserReport {

    public static void main(String[] args) {

        String reportFilePath = "user_report.txt";

        // Try-with-resources ensures the writer is closed automatically,
        // even if an exception is thrown mid-write.
        // BufferedWriter wraps FileWriter for performance — without it,
        // every write() call is a separate OS-level disk operation.
        try (BufferedWriter reportWriter = new BufferedWriter(new FileWriter(reportFilePath))) {

            // Write the report header
            reportWriter.write("=== Monthly User Report ===");
            reportWriter.newLine(); // platform-safe newline (\r\n on Windows, \n on Unix)

            reportWriter.write("Username: alice_dev");
            reportWriter.newLine();

            reportWriter.write("Logins this month: 47");
            reportWriter.newLine();

            reportWriter.write("Status: Active");
            reportWriter.newLine();

            // No need to call flush() or close() — try-with-resources does it
            System.out.println("Report written successfully to: " + reportFilePath);

        } catch (IOException writeException) {
            // IOException covers: file not found, permission denied, disk full, etc.
            System.err.println("Failed to write report: " + writeException.getMessage());
        }
    }
}

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

public class AppendEventLog {

    // Centralized log path — in a real app this comes from config
    private static final String LOG_FILE_PATH = "application_events.log";
    private static final DateTimeFormatter TIMESTAMP_FORMAT =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static void logEvent(String eventMessage) throws IOException {
        // The 'true' argument is the key — it enables append mode.
        // Without it, every call to logEvent() would destroy the previous log.
        try (BufferedWriter logWriter = new BufferedWriter(new FileWriter(LOG_FILE_PATH, true))) {

            String timestamp = LocalDateTime.now().format(TIMESTAMP_FORMAT);

            // Format: [2024-06-15 14:32:01] User alice_dev logged in
            logWriter.write("[" + timestamp + "] " + eventMessage);
            logWriter.newLine();
        }
        // Writer is closed here — the OS commits this line to disk
    }

    public static void main(String[] args) throws IOException {
        // Simulate three events happening across one session
        logEvent("Application started");
        logEvent("User alice_dev logged in");
        logEvent("User alice_dev exported report");

        System.out.println("Events logged. Check: " + LOG_FILE_PATH);
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class ReadConfigFile {

    // Assume this file exists on disk with the content shown in the output section
    private static final String CONFIG_FILE_PATH = "app_config.properties";

    public static Map<String, String> loadConfig(String filePath) throws IOException {
        Map<String, String> configSettings = new HashMap<>();

        // BufferedReader wraps FileReader — gives us readLine() and a memory buffer
        // so we're not hitting the disk character-by-character
        try (BufferedReader configReader = new BufferedReader(new FileReader(filePath))) {

            String currentLine;

            // readLine() returns null at end-of-file — NOT an empty string
            // This while loop is the standard Java pattern for reading all lines
            while ((currentLine = configReader.readLine()) != null) {

                // Skip blank lines and comment lines (lines starting with #)
                if (currentLine.isBlank() || currentLine.startsWith("#")) {
                    continue;
                }

                // Each line is expected to look like: db.host=localhost
                String[] keyValuePair = currentLine.split("=", 2);

                if (keyValuePair.length == 2) {
                    String settingKey = keyValuePair[0].trim();
                    String settingValue = keyValuePair[1].trim();
                    configSettings.put(settingKey, settingValue);
                }
            }
        }
        // BufferedReader (and the FileReader inside it) closed automatically here

        return configSettings;
    }

    public static void main(String[] args) {
        try {
            Map<String, String> appConfig = loadConfig(CONFIG_FILE_PATH);

            System.out.println("Loaded " + appConfig.size() + " config settings:");
            appConfig.forEach((key, value) ->
                System.out.println("  " + key + " -> " + value)
            );

        } catch (IOException configLoadException) {
            System.err.println("Could not load config: " + configLoadException.getMessage());
        }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.time.LocalDate;

public class TextFileCopier {

    /**
     * Copies a text file from sourcePath to destinationPath,
     * prepending a metadata header to the copy.
     *
     * @param sourcePath      path to the original text file
     * @param destinationPath path where the copy will be written
     * @throws IOException if either file cannot be opened or written
     */
    public static void copyWithMetadata(String sourcePath, String destinationPath)
            throws IOException {

        // Both resources declared in one try-with-resources block —
        // Java closes them both automatically, in reverse order (writer, then reader)
        try (
            BufferedReader sourceReader = new BufferedReader(new FileReader(sourcePath));
            BufferedWriter destinationWriter = new BufferedWriter(new FileWriter(destinationPath))
        ) {
            // Add a metadata header that doesn't exist in the original
            destinationWriter.write("# Copied from: " + sourcePath);
            destinationWriter.newLine();
            destinationWriter.write("# Copy date: " + LocalDate.now());
            destinationWriter.newLine();
            destinationWriter.write("# ----------------------------------------");
            destinationWriter.newLine();

            String sourceLine;
            int lineCount = 0;

            // Read source line by line — null signals we've reached the end
            while ((sourceLine = sourceReader.readLine()) != null) {
                destinationWriter.write(sourceLine);
                destinationWriter.newLine();
                lineCount++;
            }

            System.out.println("Copy complete. Lines copied: " + lineCount);
            System.out.println("Destination: " + destinationPath);
        }
        // Both streams flushed and closed here — content is safely on disk
    }

    public static void main(String[] args) {
        try {
            copyWithMetadata("original_template.txt", "template_backup_copy.txt");
        } catch (IOException copyException) {
            System.err.println("File copy failed: " + copyException.getMessage());
        }
    }
}

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

public class Utf8FileExample {

    public static void main(String[] args) throws IOException {
        String message = "Pièce de résistance — café au lait: €5,00 éñçödë";
        String filePath = "utf8_demo.txt";

        // Write using UTF-8 explicitly
        try (BufferedWriter writer = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream(filePath), StandardCharsets.UTF_8))) {
            writer.write(message);
            writer.newLine();
        }

        // Read using UTF-8 explicitly
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(new FileInputStream(filePath), StandardCharsets.UTF_8))) {
            String line = reader.readLine();
            System.out.println("Read back: " + line);
            System.out.println("Characters match: " + message.equals(line));
        }
    }
}

import java.io.*;

public class SafeFileCopy {
    public static void main(String[] args) throws IOException {
        File source = new File("input.txt");
        File dest = new File("output.txt");

        try (FileReader fr = new FileReader(source);
             FileWriter fw = new FileWriter(dest)) {

            int character;
            while ((character = fr.read()) != -1) {
                fw.write(character);
            }
        } // Both streams auto-closed here

        System.out.println("Copy complete. No file handles leaked.");
    }
}

import java.io.*;

public class BufferedFileCopy {
    public static void main(String[] args) throws IOException {
        File input = new File("large.txt");
        File output = new File("large_copy.txt");

        long start = System.nanoTime();
        try (BufferedReader reader = new BufferedReader(new FileReader(input));
             BufferedWriter writer = new BufferedWriter(new FileWriter(output))) {

            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        }
        long elapsed = System.nanoTime() - start;
        System.out.printf("Copied %s in %.2f ms%n", input.getName(), elapsed / 1_000_000.0);
    }
}