StringBuilder vs StringBuffer — ThreadLocal Pollution Fix

public class StringConcatenationComparison {

    public static void main(String[] args) {

        int iterations = 50_000;

        // --- Approach 1: Naive String concatenation ---
        long startNaive = System.currentTimeMillis();

        String naiveResult = "";
        for (int i = 0; i < iterations; i++) {
            // Each iteration creates a brand-new String object in memory
            naiveResult = naiveResult + "word ";
        }

        long naiveDuration = System.currentTimeMillis() - startNaive;
        System.out.println("Naive String concatenation took: " + naiveDuration + " ms");

        // --- Approach 2: StringBuilder ---
        long startBuilder = System.currentTimeMillis();

        // One mutable buffer — no intermediate objects created
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < iterations; i++) {
            builder.append("word "); // writes into the internal char[] array
        }
        String builderResult = builder.toString(); // ONE String object created here

        long builderDuration = System.currentTimeMillis() - startBuilder;
        System.out.println("StringBuilder took:             " + builderDuration + " ms");

        // Prove both produce the same output
        System.out.println("Results match: " + naiveResult.equals(builderResult));
    }
}

public class StringBuilderDeepDive {

    public static void main(String[] args) {

        // --- 1. Pre-sized capacity for performance ---
        // If you know the output will be ~200 chars, say so upfront
        StringBuilder csvRow = new StringBuilder(200);

        String[] columns = {"Alice", "32", "Engineer", "London", "true"};
        for (int i = 0; i < columns.length; i++) {
            csvRow.append(columns[i]);
            if (i < columns.length - 1) {
                csvRow.append(","); // delimiter — only between items, not after the last
            }
        }
        System.out.println("CSV Row: " + csvRow);

        // --- 2. Method chaining (fluent API) ---
        String httpRequest = new StringBuilder()
                .append("GET /api/users HTTP/1.1").append("\n")
                .append("Host: api.example.com").append("\n")
                .append("Accept: application/json").append("\n")
                .toString(); // produce the final immutable String

        System.out.println("--- HTTP Request ---");
        System.out.println(httpRequest);

        // --- 3. insert() — underused but powerful ---
        StringBuilder message = new StringBuilder("Hello World");
        message.insert(5, ","); // insert a comma at index 5
        System.out.println("After insert: " + message); // Hello, World

        // --- 4. delete() and reverse() ---
        StringBuilder logEntry = new StringBuilder("ERROR: disk full");
        logEntry.delete(0, 7);           // remove the "ERROR: " prefix
        System.out.println("Trimmed log: " + logEntry); // disk full

        StringBuilder palindromeCheck = new StringBuilder("racecar");
        String original = palindromeCheck.toString();
        String reversed = palindromeCheck.reverse().toString();
        System.out.println("Is palindrome: " + original.equals(reversed));

        // --- 5. Current capacity vs length ---
        StringBuilder capacityDemo = new StringBuilder(); // default capacity: 16
        System.out.println("Initial capacity: " + capacityDemo.capacity()); // 16
        capacityDemo.append("Hello");
        System.out.println("Length after append: " + capacityDemo.length());   // 5
        System.out.println("Capacity unchanged: " + capacityDemo.capacity()); // still 16
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class StringBufferThreadSafetyDemo {

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

        // --- Demo 1: StringBuffer is safe when shared across threads ---
        // Each synchronized append() completes atomically before the next begins
        StringBuffer sharedBuffer = new StringBuffer();

        ExecutorService threadPool = Executors.newFixedThreadPool(3);

        // Three threads all appending to the same buffer simultaneously
        for (int threadId = 1; threadId <= 3; threadId++) {
            final int id = threadId;
            threadPool.submit(() -> {
                for (int i = 0; i < 5; i++) {
                    sharedBuffer.append("T" + id + " "); // each append is thread-safe
                }
            });
        }

        threadPool.shutdown();
        threadPool.awaitTermination(5, TimeUnit.SECONDS);

        // No characters will be garbled or lost — StringBuffer guarantees this
        System.out.println("Total chars appended: " + sharedBuffer.length());
        System.out.println("Buffer content: " + sharedBuffer.toString());

        // --- Demo 2: Why StringBuffer still isn't enough for compound operations ---
        // 'Synchronized methods' doesn't mean 'synchronized workflows'
        // This check-then-act pattern is NOT atomic even with StringBuffer:
        //
        //   if (sharedBuffer.length() < 100) {     <-- thread A reads length
        //       sharedBuffer.append("new data");   <-- thread B also reads length here!
        //   }                                      <-- both threads append: race condition
        //
        // For this you need external synchronization or a different design entirely.

        System.out.println("\n--- Performance Comparison ---");

        int ops = 100_000;

        // StringBuffer with lock overhead
        StringBuffer buffer = new StringBuffer();
        long start1 = System.nanoTime();
        for (int i = 0; i < ops; i++) {
            buffer.append("x");
        }
        long bufferTime = System.nanoTime() - start1;

        // StringBuilder — no lock, no overhead
        StringBuilder builder = new StringBuilder();
        long start2 = System.nanoTime();
        for (int i = 0; i < ops; i++) {
            builder.append("x");
        }
        long builderTime = System.nanoTime() - start2;

        System.out.printf("StringBuffer:  %,d ns%n", bufferTime);
        System.out.printf("StringBuilder: %,d ns%n", builderTime);
        System.out.printf("StringBuilder was %.1fx faster%n",
                (double) bufferTime / builderTime);
    }
}

import java.util.List;
import java.util.StringJoiner;

public class RealWorldStringBuilderPatterns {

    // --- Pattern 1: Building a clean toString() method ---
    static class Order {
        private final int orderId;
        private final String customerName;
        private final List<String> items;
        private final double totalAmount;

        Order(int orderId, String customerName, List<String> items, double totalAmount) {
            this.orderId = orderId;
            this.customerName = customerName;
            this.items = items;
            this.totalAmount = totalAmount;
        }

        @Override
        public String toString() {
            // Pre-size based on rough estimate — avoids internal resize copies
            StringBuilder sb = new StringBuilder(128);
            sb.append("Order{id=").append(orderId)
              .append(", customer='").append(customerName).append("'")
              .append(", items=").append(items.size())
              .append(", total=$").append(String.format("%.2f", totalAmount))
              .append("}");
            return sb.toString();
        }
    }

    // --- Pattern 2: Building a parameterised query string safely ---
    static String buildSearchQuery(String keyword, String category, int maxResults) {
        StringBuilder query = new StringBuilder("/api/products?");

        // Only add parameters that are actually provided
        boolean firstParam = true;

        if (keyword != null && !keyword.isBlank()) {
            query.append("q=").append(keyword);
            firstParam = false;
        }
        if (category != null && !category.isBlank()) {
            if (!firstParam) query.append("&");
            query.append("category=").append(category);
            firstParam = false;
        }
        if (maxResults > 0) {
            if (!firstParam) query.append("&");
            query.append("limit=").append(maxResults);
        }

        return query.toString();
    }

    // --- Pattern 3: StringJoiner — the modern alternative for delimited lists ---
    static String buildCsvHeader(List<String> columnNames) {
        // StringJoiner handles the delimiter logic for you — no trailing comma issues
        StringJoiner joiner = new StringJoiner(",", "", "\n"); // delimiter, prefix, suffix
        for (String column : columnNames) {
            joiner.add(column.toUpperCase());
        }
        return joiner.toString();
    }

    public static void main(String[] args) {
        Order order = new Order(10245, "Alice Chen",
                List.of("Laptop", "Mouse", "USB Hub"), 1249.99);
        System.out.println(order);

        System.out.println(buildSearchQuery("java book", "tech", 20));
        System.out.println(buildSearchQuery(null, "fiction", 10));
        System.out.println(buildSearchQuery("keyboard", null, 0));

        List<String> headers = List.of("id", "name", "email", "joinDate");
        System.out.print(buildCsvHeader(headers));
    }
}

public class CapacityTuningDemo {

    public static void main(String[] args) {
        int iterations = 1_000_000;

        // --- Without capacity hint: multiple resizes ---
        long start = System.nanoTime();
        StringBuilder sb = new StringBuilder(); // default 16
        for (int i = 0; i < iterations; i++) {
            sb.append("x");
        }
        long noHint = System.nanoTime() - start;

        // --- With capacity hint ---
        start = System.nanoTime();
        StringBuilder sb2 = new StringBuilder(iterations); // 1_000_000
        for (int i = 0; i < iterations; i++) {
            sb2.append("x");
        }
        long withHint = System.nanoTime() - start;

        System.out.printf("No capacity hint: %d ns%n", noHint);
        System.out.printf("With capacity hint: %d ns%n", withHint);
        System.out.printf("Speedup: %.2fx%n", (double) noHint / withHint);
    }
}

// io.thecodeforge
public class HeapPressureDemo {
    // BAD: 10,000 allocations, high GC churn
    public String buildResponseBad(List<String> items) {
        String result = "";
        for (String item : items) {
            result += "<item>" + item + "</item>";
        }
        return "<root>" + result + "</root>";
    }

    // GOOD: 3-5 allocations total
    public String buildResponseGood(List<String> items) {
        // Estimate capacity: <root> + items * (avg item len + 20) 
        StringBuilder sb = new StringBuilder(items.size() * 50);
        sb.append("<root>");
        for (String item : items) {
            sb.append("<item>").append(item).append("</item>");
        }
        sb.append("</root>");
        return sb.toString();
    }
}

// io.thecodeforge
// Spring Boot controller - still single-threaded per request
@RestController
@RequestMapping("/api/reports")
public class ReportController {
    
    // WRONG: StringBuffer on a local variable = wasted synchronization
    @GetMapping("/{id}")
    public String getReportSync(@PathVariable String id) {
        StringBuffer sb = new StringBuffer(256);
        sb.append("Report_for_").append(id);
        // ... more single-threaded work
        return sb.toString();
    }
    
    // RIGHT: StringBuilder in local scope
    @GetMapping("/v2/{id}")
    public String getReportAsync(@PathVariable String id) {
        StringBuilder sb = new StringBuilder(256);
        sb.append("Report_for_").append(id);
        // ... exactly the same work, no lock overhead
        return sb.toString();
    }
}