Java File Handling — Data Loss from Unflushed Buffers

package io.thecodeforge.filehandling;

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

package io.thecodeforge.filehandling;

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

package io.thecodeforge.filehandling;

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

package io.thecodeforge.filehandling;

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

package io.thecodeforge.filehandling;

import java.io.*;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

public class FileCopierBinary {

    // Copy using BufferedInputStream/OutputStream — good for moderate file sizes
    public static void copyBuffered(Path source, Path target) throws IOException {
        try (InputStream in = new BufferedInputStream(new FileInputStream(source.toFile()));
             OutputStream out = new BufferedOutputStream(new FileOutputStream(target.toFile()))) {

            byte[] buffer = new byte[8192]; // 8 KB typical buffer
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
        }
        // try-with-resources ensures both streams are closed
    }

    // Copy using FileChannel with transferTo() — faster for large files, zero-copy on many OS
    public static void copyChannel(Path source, Path target) throws IOException {
        try (FileChannel srcChannel = FileChannel.open(source, StandardOpenOption.READ);
             FileChannel destChannel = FileChannel.open(target, StandardOpenOption.CREATE_NEW,
                 StandardOpenOption.WRITE)) {

            // transferTo uses OS-level sendfile() under the hood — avoids copying bytes into Java heap
            long position = 0;
            long size = srcChannel.size();
            while (position < size) {
                position += srcChannel.transferTo(position, size - position, destChannel);
            }
        }
    }

    public static void main(String[] args) throws IOException {
        Path source = Path.of("large-file.bin");
        Path target1 = Path.of("large-file-buffered.bin");
        Path target2 = Path.of("large-file-channel.bin");

        long start = System.nanoTime();
        copyBuffered(source, target1);
        long bufferedTime = System.nanoTime() - start;
        System.out.println("Buffered copy: " + bufferedTime / 1_000_000 + " ms");

        start = System.nanoTime();
        copyChannel(source, target2);
        long channelTime = System.nanoTime() - start;
        System.out.println("Channel copy: " + channelTime / 1_000_000 + " ms");
    }
}