PrintWriter vs PrintStream — Avoid Encoding Corruption

import java.io.PrintStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class PrintStreamDemo {

    public static void main(String[] args) throws IOException {

        // System.out is already a PrintStream — this is the one everyone knows
        System.out.println("Logging to the console via System.out (a PrintStream)");

        // You can create a PrintStream that writes to a file
        // Notice we explicitly set UTF-8 to avoid platform-encoding surprises
        try (PrintStream filePrintStream = new PrintStream(
                new FileOutputStream("server_log.txt"),
                true,                          // auto-flush after every println
                StandardCharsets.UTF_8.name()  // always specify encoding!
        )) {
            filePrintStream.println("Server started at: " + java.time.Instant.now());
            filePrintStream.printf("Active threads: %d%n", Thread.activeCount());
            filePrintStream.println("Status: RUNNING");

            // PrintStream swallows IOExceptions — check for silent failures like this
            if (filePrintStream.checkError()) {
                System.err.println("WARNING: PrintStream encountered a write error!");
            }
        }

        // Redirect System.out to a custom PrintStream (useful in testing)
        PrintStream originalOut = System.out; // save the original
        try (PrintStream captureStream = new PrintStream("captured_output.txt")) {
            System.setOut(captureStream);      // redirect all System.out calls
            System.out.println("This line goes to the file, not the console");
        } finally {
            System.setOut(originalOut);        // ALWAYS restore — or you lose your console
            System.out.println("Console output restored successfully");
        }
    }
}

import java.io.PrintWriter;
import java.io.FileWriter;
import java.io.OutputStreamWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;

public class PrintWriterDemo {

    // Simulated report data — imagine this comes from a database
    record SalesRecord(String region, int unitsSold, double revenue) {}

    public static void main(String[] args) {

        List<SalesRecord> salesData = List.of(
            new SalesRecord("North America", 1420,  98500.00),
            new SalesRecord("Europe",        987,   72340.50),
            new SalesRecord("Asia-Pacific",  2103, 134200.75)
        );

        // Best practice: OutputStreamWriter lets you control encoding explicitly
        // Wrap it in PrintWriter for the convenient print/printf API
        try (PrintWriter reportWriter = new PrintWriter(
                new OutputStreamWriter(
                    new FileOutputStream("quarterly_report.txt"),
                    StandardCharsets.UTF_8  // explicit UTF-8 — never rely on platform default
                )
        )) {
            // Write a formatted report header
            reportWriter.println("=== Q1 Sales Report ===");
            reportWriter.println("Generated: " + java.time.LocalDate.now());
            reportWriter.println();

            // printf works identically to String.format — very readable output
            reportWriter.printf("%-20s %12s %15s%n", "Region", "Units Sold", "Revenue (USD)");
            reportWriter.println("-".repeat(50));

            double totalRevenue = 0;
            for (SalesRecord record : salesData) {
                reportWriter.printf("%-20s %12d %,15.2f%n",
                    record.region(),
                    record.unitsSold(),
                    record.revenue()
                );
                totalRevenue += record.revenue();
            }

            reportWriter.println("-".repeat(50));
            reportWriter.printf("%-20s %12s %,15.2f%n", "TOTAL", "", totalRevenue);

            // PrintWriter also swallows IOExceptions after construction
            // checkError() is your safety net for critical output
            if (reportWriter.checkError()) {
                System.err.println("ERROR: Report write failed — check disk space!");
            } else {
                System.out.println("Report written successfully.");
            }

        } catch (IOException setupException) {
            // This fires if the file can't be created or opened — loud and clear
            System.err.println("Could not create report file: " + setupException.getMessage());
        }
    }
}

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

public class FlushingBehaviourDemo {

    public static void main(String[] args) throws IOException {

        // ── SCENARIO 1: Auto-flush ENABLED ──────────────────────────────────
        // Pass 'true' as the second argument to enable auto-flush
        // Each println() immediately pushes data through to the file
        // Good for: audit logs, event logs, anything where crash-safety matters
        System.out.println("--- Scenario 1: Auto-flush enabled ---");
        try (PrintWriter auditLog = new PrintWriter(
                new OutputStreamWriter(
                    new FileOutputStream("audit_log.txt"),
                    StandardCharsets.UTF_8
                ),
                true // AUTO-FLUSH ON — every println/printf flushes immediately
        )) {
            auditLog.println("[" + Instant.now() + "] User 'alice' logged in");
            auditLog.println("[" + Instant.now() + "] User 'alice' accessed /admin");
            // Even if the app crashes here, both lines are safely on disk
            auditLog.printf("[%s] Permission denied for user 'alice'%n", Instant.now());
            System.out.println("Audit entries written (each flushed immediately)");
        }

        // ── SCENARIO 2: Buffered writer WITHOUT auto-flush ───────────────────
        // Good for: writing large reports, CSV exports — performance matters
        // Risk: if you forget flush(), data in the buffer is LOST on crash
        System.out.println("\n--- Scenario 2: Buffered, manual flush ---");
        try (PrintWriter reportWriter = new PrintWriter(
                new BufferedWriter(   // BufferedWriter adds a write buffer for speed
                    new OutputStreamWriter(
                        new FileOutputStream("bulk_report.csv"),
                        StandardCharsets.UTF_8
                    ),
                    8192 // 8 KB buffer — reduces filesystem calls significantly
                )
                // No 'true' here — auto-flush is OFF
        )) {
            reportWriter.println("id,name,score");

            for (int studentId = 1; studentId <= 5; studentId++) {
                // print() does NOT auto-flush even with auto-flush enabled on PrintWriter
                // Use println() or printf() if you rely on auto-flush
                reportWriter.printf("%d,Student_%d,%d%n",
                    studentId, studentId, 60 + studentId * 5);
            }

            // The try-with-resources close() calls flush() then close()
            // So data IS written here — but ONLY because we're using try-with-resources
            System.out.println("CSV written — buffer flushed by auto-close");
        }

        // ── SCENARIO 3: The crash simulation ─────────────────────────────────
        // This demonstrates what happens without proper flushing
        System.out.println("\n--- Scenario 3: What happens without flush ---");
        PrintWriter dangerousWriter = new PrintWriter(
            new BufferedWriter(
                new OutputStreamWriter(
                    new FileOutputStream("dangerous_log.txt"),
                    StandardCharsets.UTF_8
                )
            )
        );
        dangerousWriter.println("This line might never reach disk!");
        // Simulating a crash: we 'forget' to close or flush
        // If the JVM exits abnormally here, the file will be empty
        // Always use try-with-resources to prevent this
        dangerousWriter.flush(); // explicitly saving ourselves here
        dangerousWriter.close();
        System.out.println("Saved! But you should use try-with-resources instead.");
    }
}

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.time.LocalDate;
import java.util.List;

public class ReportGenerator {

    // A simple domain object — imagine this comes from your service layer
    record ProductSummary(String productName, int quantitySold, double unitPrice) {
        double totalRevenue() { return quantitySold * unitPrice; }
    }

    /**
     * Core report logic — completely decoupled from WHERE the output goes.
     * The caller injects the PrintWriter, so this method is trivially testable.
     */
    public static void writeInventoryReport(
            PrintWriter destination,
            List<ProductSummary> products,
            String storeName
    ) {
        destination.println("╔══════════════════════════════════════════╗");
        destination.printf( "║  Inventory Report — %-21s║%n", storeName);
        destination.printf( "║  Date: %-33s║%n", LocalDate.now());
        destination.println("╚══════════════════════════════════════════╝");
        destination.println();

        destination.printf("%-25s %10s %12s %15s%n",
            "Product", "Qty Sold", "Unit Price", "Total Revenue");
        destination.println("─".repeat(65));

        double grandTotal = 0;
        for (ProductSummary product : products) {
            destination.printf("%-25s %10d %,12.2f %,15.2f%n",
                product.productName(),
                product.quantitySold(),
                product.unitPrice(),
                product.totalRevenue()
            );
            grandTotal += product.totalRevenue();
        }

        destination.println("─".repeat(65));
        destination.printf("%-25s %10s %12s %,15.2f%n",
            "GRAND TOTAL", "", "", grandTotal);
        destination.println();
        destination.printf("Report contains %d product line(s).%n", products.size());
    }

    public static void main(String[] args) throws IOException {

        List<ProductSummary> storeInventory = List.of(
            new ProductSummary("Wireless Headphones",  345,  89.99),
            new ProductSummary("USB-C Hub",            892,  34.50),
            new ProductSummary("Mechanical Keyboard",  217, 149.00),
            new ProductSummary("Webcam HD 1080p",      430,  59.95)
        );

        // ── Output 1: Write to a UTF-8 file for archiving ────────────────────
        try (PrintWriter fileDestination = new PrintWriter(
                new OutputStreamWriter(
                    new FileOutputStream("inventory_report_2024_Q1.txt"),
                    StandardCharsets.UTF_8
                ),
                false // buffered — we'll flush on close via try-with-resources
        )) {
            writeInventoryReport(fileDestination, storeInventory, "London Flagship");
            System.out.println("Archived to: inventory_report_2024_Q1.txt");
        }

        // ── Output 2: Same method, same data — now to the console ────────────
        // System.out is a PrintStream but we wrap it as a PrintWriter
        // OutputStreamWriter handles the bridge between Writer and OutputStream
        try (PrintWriter consoleDestination = new PrintWriter(
                new OutputStreamWriter(System.out, StandardCharsets.UTF_8),
                true // auto-flush for console — we want immediate output
        )) {
            System.out.println("\n── Live Console Output ──");
            writeInventoryReport(consoleDestination, storeInventory, "London Flagship");
        }

        // ── Output 3: Testing pattern — capture output in memory ─────────────
        // No files, no console — just a string you can assert against in tests
        StringWriter capturedOutput = new StringWriter();
        try (PrintWriter testDestination = new PrintWriter(capturedOutput)) {
            writeInventoryReport(testDestination, storeInventory, "Test Store");
        }
        String reportAsString = capturedOutput.toString();
        boolean reportIsValid = reportAsString.contains("GRAND TOTAL")
                             && reportAsString.contains("Wireless Headphones");
        System.out.println("\nReport validation passed: " + reportIsValid);
    }
}

package io.thecodeforge;

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

public class PerformanceComparison {
    public static void main(String[] args) throws IOException {
        // Simple benchmark: write 100,000 lines with each approach
        long start, end;

        // PrintStream without explicit encoding (worst case)
        start = System.currentTimeMillis();
        try (PrintStream ps = new PrintStream(new FileOutputStream("ps_default.txt"))) {
            for (int i = 0; i < 100_000; i++) {
                ps.println("Line " + i);
            }
        }
        end = System.currentTimeMillis();
        System.out.println("PrintStream (default encoding): " + (end - start) + "ms");

        // PrintWriter with explicit UTF-8 + BufferedWriter
        start = System.currentTimeMillis();
        try (PrintWriter pw = new PrintWriter(
                new BufferedWriter(
                    new OutputStreamWriter(
                        new FileOutputStream("pw_utf8.txt"),
                        StandardCharsets.UTF_8
                    ),
                    8192
                )
        )) {
            for (int i = 0; i < 100_000; i++) {
                pw.println("Line " + i);
            }
        }
        end = System.currentTimeMillis();
        System.out.println("PrintWriter + BufferedWriter (UTF-8): " + (end - start) + "ms");
    }
}