Variables and Scopes — Optimize the Code¶

public class Main {
    int[] data;

    public Main(int size) {
        data = new int[size];
        for (int i = 0; i < size; i++) {
            data[i] = i + 1;
        }
    }

    public long computeSum() {
        // Cache field in local variable — JIT can register-allocate locals
        int[] localData = data;
        int len = localData.length;
        long sum = 0;
        for (int i = 0; i < len; i++) {
            sum += localData[i];
        }
        return sum;
    }

    public static void main(String[] args) {
        Main obj = new Main(10_000_000);
        long start = System.nanoTime();
        long result = 0;
        for (int iter = 0; iter < 100; iter++) {
            result = obj.computeSum();
        }
        long elapsed = (System.nanoTime() - start) / 100;
        System.out.println("Sum: " + result);
        System.out.println("Avg time: " + elapsed + " ns");
    }
}

public class Main {
    public static void main(String[] args) {
        int count = 0;
        int limit = 10_000_000;

        long start = System.nanoTime();
        for (int i = 0; i < limit; i++) {
            if (i % 3 == 0) {
                count++;
            }
        }
        long elapsed = System.nanoTime() - start;

        System.out.println("Count: " + count);
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        long phase1Result;

        // Phase 1: Scoped in a block — bigData is GC-eligible when block ends
        {
            List<byte[]> bigData = new ArrayList<>();
            for (int i = 0; i < 100; i++) {
                bigData.add(new byte[1024 * 1024]);
            }
            phase1Result = bigData.size();
            System.out.println("Phase 1 loaded: " + phase1Result + " chunks");
        }
        // bigData reference is now out of scope — GC can reclaim 100 MB

        System.gc(); // Suggest GC (for demonstration)

        // Phase 2: Runs with freed memory
        long sum = 0;
        for (int i = 0; i < 50_000_000; i++) {
            sum += i;
        }
        System.out.println("Phase 2 result: " + sum);

        Runtime rt = Runtime.getRuntime();
        System.out.println("Memory used: " + (rt.totalMemory() - rt.freeMemory()) / (1024 * 1024) + " MB");
    }
}

import java.util.List;

public class Main {
    StringBuilder report = new StringBuilder(1024 * 64); // Pre-sized

    public void addSection(String title, List<String> items) {
        report.append("=== ").append(title).append(" ===\n");
        for (String item : items) {
            report.append("  - ").append(item).append('\n');
        }
        report.append('\n');
    }

    public static void main(String[] args) {
        Main builder = new Main();
        long start = System.nanoTime();

        for (int section = 0; section < 1000; section++) {
            builder.addSection("Section " + section,
                List.of("Item A", "Item B", "Item C", "Item D", "Item E"));
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Report length: " + builder.report.length());
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

public class Main {
    final double basePrice;
    final double taxPercent;
    final String currency;
    final double taxMultiplier;  // Precomputed
    final double totalPrice;     // Cached

    public Main(double basePrice, double taxPercent, String currency) {
        this.basePrice = basePrice;
        this.taxPercent = taxPercent;
        this.currency = currency;
        this.taxMultiplier = 1.0 + (taxPercent / 100.0); // Compute once
        this.totalPrice = basePrice * taxMultiplier;       // Cache result
    }

    public double getTotalPrice() {
        return totalPrice; // Simple field read
    }

    public String getFormattedPrice() {
        return String.format("%s %.2f", currency, totalPrice);
    }

    public static void main(String[] args) {
        Main item = new Main(99.99, 20.0, "USD");
        long start = System.nanoTime();

        String result = "";
        for (int i = 0; i < 5_000_000; i++) {
            result = item.getFormattedPrice();
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Price: " + result);
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        // Key range is 0-999 — use a primitive array instead of Map<Integer, Integer>
        int[] frequency = new int[1000];
        Random random = new Random(42);

        long start = System.nanoTime();

        for (int i = 0; i < 10_000_000; i++) {
            int reading = random.nextInt(1000);
            frequency[reading]++; // No boxing, no hashing, no Map overhead
        }

        long elapsed = System.nanoTime() - start;

        int distinct = 0;
        for (int count : frequency) {
            if (count > 0) distinct++;
        }

        System.out.println("Distinct values: " + distinct);
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        long[] eventTimestamps = new long[1_000_000];
        long baseTime = System.currentTimeMillis();
        for (int i = 0; i < eventTimestamps.length; i++) {
            eventTimestamps[i] = baseTime + (i * 1000L);
        }

        long start = System.nanoTime();

        // Hoist reusable objects out of the loop
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = new Date();

        String lastFormatted = "";
        for (long timestamp : eventTimestamps) {
            date.setTime(timestamp); // Reuse Date object
            lastFormatted = sdf.format(date);
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Last: " + lastFormatted);
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

public class Main {
    double[] xs; // Parallel arrays — no per-point object
    double[] ys;
    int size = 0;

    public Main(int capacity) {
        xs = new double[capacity];
        ys = new double[capacity];
    }

    public void addPoint(double x, double y) {
        xs[size] = x;
        ys[size] = y;
        size++;
    }

    public double totalDistance() {
        double total = 0;
        // Cache fields in locals for tight loop
        double[] localXs = xs;
        double[] localYs = ys;
        int localSize = size;

        for (int i = 1; i < localSize; i++) {
            double dx = localXs[i] - localXs[i - 1];
            double dy = localYs[i] - localYs[i - 1];
            total += Math.sqrt(dx * dx + dy * dy);
        }
        return total;
    }

    public static void main(String[] args) {
        Main calc = new Main(1_000_000);
        for (int i = 0; i < 1_000_000; i++) {
            calc.addPoint(i * 0.1, i * 0.2);
        }

        long start = System.nanoTime();
        double result = 0;
        for (int iter = 0; iter < 10; iter++) {
            result = calc.totalDistance();
        }
        long elapsed = (System.nanoTime() - start) / 10;

        System.out.println("Total distance: " + result);
        System.out.println("Avg time: " + elapsed / 1_000_000 + " ms");
    }
}

public class Main {
    // If values are truly constant, use static final — JIT can inline them
    static final double MULTIPLIER = 2.5;
    static final double OFFSET = 10.0;

    public static void transform(double[] values) {
        // Cache length for loop bound
        int len = values.length;
        for (int i = 0; i < len; i++) {
            values[i] = values[i] * MULTIPLIER + OFFSET; // Constant-folded by JIT
        }
    }

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

        long start = System.nanoTime();
        for (int iter = 0; iter < 50; iter++) {
            transform(data);
        }
        long elapsed = (System.nanoTime() - start) / 50;

        System.out.println("First: " + data[0] + ", Last: " + data[data.length - 1]);
        System.out.println("Avg time: " + elapsed / 1_000_000 + " ms");
    }
}

import java.text.NumberFormat;
import java.util.Locale;

public class Main {
    // Each thread gets its own formatter — no synchronization needed
    static final ThreadLocal<NumberFormat> formatter =
        ThreadLocal.withInitial(() -> NumberFormat.getCurrencyInstance(Locale.US));

    public static String formatPrice(double price) {
        return formatter.get().format(price); // Thread-local access, no lock
    }

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

        long start = System.nanoTime();

        for (int t = 0; t < threadCount; t++) {
            threads[t] = new Thread(() -> {
                for (int i = 0; i < iterationsPerThread; i++) {
                    formatPrice(i * 1.01);
                }
                formatter.remove(); // Clean up to prevent memory leak
            });
            threads[t].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        long elapsed = System.nanoTime() - start;
        System.out.println("Total: " + (threadCount * iterationsPerThread) + " formats");
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}

import java.util.BitSet;

public class Main {
    static boolean isValid(int amount, boolean isActive, String type) {
        return amount > 0 && isActive && type != null && !type.isEmpty();
    }

    public static void main(String[] args) {
        int count = 5_000_000;
        BitSet results = new BitSet(count); // 1 bit per result vs 16+ bytes per Boolean

        long start = System.nanoTime();
        for (int i = 0; i < count; i++) {
            if (isValid(i % 1000, i % 2 == 0, "purchase")) {
                results.set(i);
            }
        }
        long elapsed = System.nanoTime() - start;

        System.out.println("Valid: " + results.cardinality());
        System.out.println("Time: " + elapsed / 1_000_000 + " ms");
    }
}