PrintWriter vs PrintStream — Avoid Encoding Corruption

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

// io.thecodeforge — java tutorial

import java.io.*;

public class SilentFailureDemo {
    public static void main(String[] args) throws IOException {
        // FileOutputStream to a valid path but then we'll close the underlying stream early
        FileOutputStream fos = new FileOutputStream("report.csv");
        PrintWriter pw = new PrintWriter(fos);

        pw.println("header1,header2,header3");
        fos.close(); // close underlying stream while PrintWriter still thinks it's open

        pw.println("data1,data2,data3"); // this write fails silently
        pw.flush();

        // No exception thrown. You must check manually.
        if (pw.checkError()) {
            System.err.println("CRITICAL: Write operation failed — output may be incomplete.");
        }
        pw.close();
    }
}

// io.thecodeforge — java tutorial

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

public class BinaryVsText {
    public static void main(String[] args) throws IOException {
        // Binary header + text — PrintStream only
        try (FileOutputStream fos = new FileOutputStream("network_packet.bin");
             PrintStream ps = new PrintStream(fos)) {
            byte[] header = {0x02, (byte) 0xFF, 0x0A};
            ps.write(header); // raw binary works
            ps.println("PAYLOAD:transaction_id=4412"); // text works too
        }

        // Same attempt with PrintWriter — fails at compile time for write(byte[])
        // PrintWriter pw = new PrintWriter(new FileOutputStream("packet.bin"));
        // pw.write(header); // COMPILE ERROR: no write(byte[]) method
        
        System.out.println("Binary packet written successfully.");
    }
}

// io.thecodeforge — java tutorial

import java.io.*;

public class FlushMismatch {
    public static void main(String[] args) throws IOException {
        // PrintStream: flushes on every newline character
        try (PrintStream ps = new PrintStream(new FileOutputStream("debug.log"), true)) {
            ps.print("line1\nline2\n"); // two flushes happen here
        }

        // PrintWriter: does NOT flush on embedded newlines
        try (PrintWriter pw = new PrintWriter(new FileWriter("report.txt", true), true)) {
            pw.print("header\n"); // no flush — no println called
            pw.println("body");    // flush happens here
        }
        
        System.out.println("Flush behavior differs — check log sizes.");
    }
}

// io.thecodeforge — java tutorial

import java.io.PrintWriter;

public class ResettableWriter extends PrintWriter {
    public ResettableWriter(String file) throws Exception {
        super(new java.io.FileWriter(file), true);
    }

    public void clear() {
        clearError(); // protected — only accessible via subclass
    }

    public static void main(String[] args) throws Exception {
        var w = new ResettableWriter("/tmp/test.log");
        w.println("first");
        w.checkError(); // false
        w.clear(); // reset any latent error flag
        System.out.println("Error cleared");
        w.close();
    }
}

// io.thecodeforge — java tutorial

import java.io.*;

public class BinaryMixer {
    public static void main(String[] args) throws Exception {
        var ps = new PrintStream(new FileOutputStream("/tmp/out.bin"));
        ps.print("P6\n"); // header
        byte[] pixels = { (byte)255, 0, (byte)128 };
        ps.write(pixels); // raw bytes — no encoding
        ps.println();
        ps.close();
        // PrintWriter would encode pixels as chars
        System.out.println("Binary header + raw pixels written");
    }
}

// io.thecodeforge — java tutorial
import java.io.*;
public class EncodingExample {
    public static void main(String[] args) throws Exception {
        String text = "café résumé";
        // PrintWriter with explicit UTF-8 — safe
        try (PrintWriter pw = new PrintWriter(
                new FileWriter("output.txt", java.nio.charset.StandardCharsets.UTF_8))) {
            pw.println(text);
        }
        // PrintStream uses default charset — may corrupt
        PrintStream ps = new PrintStream(
                new FileOutputStream("output2.txt"));
        ps.println(text);
        ps.close();
    }
}

// io.thecodeforge — java tutorial
import java.io.*;
public class FlushExample {
    public static void main(String[] args) throws Exception {
        try (PrintWriter pw = new PrintWriter(
                new BufferedWriter(
                    new FileWriter("log.txt", java.nio.charset.StandardCharsets.UTF_8)),
                8192)) {
            pw.println("Batch log entry 1");
            pw.println("Batch log entry 2");
            // No auto-flush on newline — flushes only when buffer full
        } // try-with-resources auto-flushes on close
    }
}