Lifecycle of a Java Program — Optimize the Code¶

public class Main {
    public static String buildReport(int count) {
        StringBuilder sb = new StringBuilder(count * 15);  // Pre-size the buffer
        for (int i = 0; i < count; i++) {
            sb.append("Item ").append(i).append('\n');
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        long start = System.nanoTime();
        String result = buildReport(10_000);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Length: %d, Time: %d ms%n", result.length(), elapsed);
    }
}

public class Main {
    public static long sumValues(int[] values) {
        long sum = 0L;  // Primitive long — no boxing
        for (int value : values) {
            if (value > 0) {
                sum += value;  // Primitive arithmetic — no object creation
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] data = new int[1_000_000];
        for (int i = 0; i < data.length; i++) data[i] = i;

        long start = System.nanoTime();
        long result = sumValues(data);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Sum: %d, Time: %d ms%n", result, elapsed);
    }
}

import java.lang.reflect.Constructor;
import java.util.concurrent.ConcurrentHashMap;

public class Main {
    // Cache Class objects and constructors
    private static final ConcurrentHashMap<String, Constructor<?>> CACHE = new ConcurrentHashMap<>();

    public static Object createHandler(String type) throws Exception {
        String className = "java.util." + type;
        Constructor<?> ctor = CACHE.computeIfAbsent(className, name -> {
            try {
                return Class.forName(name).getDeclaredConstructor();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });
        return ctor.newInstance();
    }

    public static void main(String[] args) throws Exception {
        long start = System.nanoTime();
        for (int i = 0; i < 100_000; i++) {
            Object obj = createHandler("HashMap");
        }
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Time: %d ms%n", elapsed);
    }
}

import java.util.*;

public class Main {
    // Eagerly initialized — always needed
    static final List<String> COMMON_WORDS = loadDictionary();

    // Lazy initialization via Holder pattern — thread-safe, zero cost if unused
    private static class RareLookupHolder {
        static final Map<String, Integer> INSTANCE = buildRareLookup();
    }

    private static class HugeIndexHolder {
        static final Map<String, List<String>> INSTANCE = buildHugeIndex();
    }

    static List<String> loadDictionary() {
        System.out.println("Loading dictionary...");
        List<String> words = new ArrayList<>();
        for (int i = 0; i < 100_000; i++) words.add("word" + i);
        return Collections.unmodifiableList(words);
    }

    static Map<String, Integer> buildRareLookup() {
        System.out.println("Building rare lookup...");
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < 50_000; i++) map.put("rare" + i, i);
        return Collections.unmodifiableMap(map);
    }

    static Map<String, List<String>> buildHugeIndex() {
        System.out.println("Building huge index...");
        Map<String, List<String>> map = new HashMap<>();
        for (int i = 0; i < 10_000; i++) {
            map.put("key" + i, List.of("val" + i));
        }
        return Collections.unmodifiableMap(map);
    }

    // Access lazy resources through holder classes
    static Map<String, Integer> getRareLookup() { return RareLookupHolder.INSTANCE; }
    static Map<String, List<String>> getHugeIndex() { return HugeIndexHolder.INSTANCE; }

    public static void main(String[] args) {
        // Only COMMON_WORDS is initialized — rare lookup and huge index are NOT loaded
        System.out.println("Using: " + COMMON_WORDS.size() + " words");
    }
}

import java.util.List;

public class Main {
    // Replace polymorphism with a data-driven approach
    public static long processAll(int[] addends, int iterations) {
        long sum = 0;
        for (int i = 0; i < iterations; i++) {
            for (int addend : addends) {
                sum += i + addend;  // Direct arithmetic — JIT can vectorize
            }
        }
        return sum;
    }

    public static void main(String[] args) {
        int[] addends = {1, 2, 3, 4, 5};

        // Warmup
        for (int i = 0; i < 10_000; i++) processAll(addends, 100);

        long start = System.nanoTime();
        long result = processAll(addends, 100_000);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Sum: %d, Time: %d ms%n", result, elapsed);
    }
}

import java.util.concurrent.atomic.LongAdder;

public class Main {
    static final LongAdder counter = new LongAdder();  // Striped counter — low contention

    static void incrementCounter(int times) {
        for (int i = 0; i < times; i++) {
            counter.increment();  // CAS on thread-local stripe — minimal contention
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 8;
        int iterPerThread = 1_000_000;
        Thread[] threads = new Thread[threadCount];

        long start = System.nanoTime();
        for (int t = 0; t < threadCount; t++) {
            threads[t] = new Thread(() -> incrementCounter(iterPerThread));
            threads[t].start();
        }
        for (Thread t : threads) t.join();
        long elapsed = (System.nanoTime() - start) / 1_000_000;

        System.out.printf("Counter: %d, Time: %d ms%n", counter.sum(), elapsed);
    }
}

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

public class Main {
    public static void main(String[] args) throws IOException {
        long start = System.nanoTime();

        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"), 64 * 1024)) {
            // 64KB buffer — batches writes, reducing syscalls
            for (int i = 0; i < 1_000_000; i++) {
                writer.write("Line ");
                writer.write(Integer.toString(i));
                writer.newLine();
            }
        }

        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Time: %d ms%n", elapsed);
    }
}

public class Main {
    // Option 1: Inline the computation — no object needed
    static long summarize(int count) {
        long total = 0;
        for (int i = 0; i < count; i++) {
            int value = i * 31 + i / 7;
            // We only use value — status and timestamp are unused
            total += value;
        }
        return total;
    }

    // Option 2: If you need multiple return values, use a reusable holder
    static class ResultHolder {
        int value;
        boolean isHigh;
        long timestamp;
    }

    static void processEvent(int eventId, ResultHolder holder) {
        holder.value = eventId * 31 + eventId / 7;
        holder.isHigh = holder.value > 1000;
        holder.timestamp = System.nanoTime();
    }

    static long summarizeWithHolder(int count) {
        long total = 0;
        ResultHolder holder = new ResultHolder();  // Single allocation, reused
        for (int i = 0; i < count; i++) {
            processEvent(i, holder);
            total += holder.value;
        }
        return total;
    }

    public static void main(String[] args) {
        // Warmup
        for (int i = 0; i < 10_000; i++) summarize(1000);

        long start = System.nanoTime();
        long result = summarize(10_000_000);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Total: %d, Time: %d ms%n", result, elapsed);
    }
}

public class Main {
    // Lazy holders — only loaded when accessed
    private static class FormatterHolder {
        static final java.time.format.DateTimeFormatter INSTANCE =
            java.time.format.DateTimeFormatter.ISO_DATE_TIME;
    }

    private static class ExecutorHolder {
        static final java.util.concurrent.ExecutorService INSTANCE =
            java.util.concurrent.Executors.newFixedThreadPool(4);
    }

    private static class TaxHolder {
        static final java.math.BigDecimal RATE = new java.math.BigDecimal("0.21");
    }

    public static void main(String[] args) {
        // Only simple computation — no heavy classes loaded
        int result = 42 * 7;
        System.out.println("Result: " + result);
        // FormatterHolder, ExecutorHolder, TaxHolder are NEVER loaded
    }
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static volatile boolean running = true;
    static final AtomicInteger processedCount = new AtomicInteger(0);

    static void worker() {
        while (running && !Thread.currentThread().isInterrupted()) {
            processedCount.incrementAndGet();  // Lock-free increment
            try { Thread.sleep(10); } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutting down...");
            running = false;

            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                    executor.awaitTermination(2, TimeUnit.SECONDS);
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
            }

            // Read counter after all workers have stopped — no lock needed
            System.out.println("Final count: " + processedCount.get());
            System.out.println("Shutdown complete.");
        }));

        for (int i = 0; i < 4; i++) {
            executor.submit(Main::worker);
        }

        Thread.sleep(2000);
        System.exit(0);
    }
}