Java Basic Syntax — Optimize the Code¶

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        // Pre-size the builder: average token ~9 chars → ~900,000 chars total
        StringBuilder sb = new StringBuilder(1_000_000);
        for (int i = 0; i < 100_000; i++) {
            sb.append("item").append(i).append(',');
        }
        String result = sb.toString();
        long elapsed = System.nanoTime() - start;
        System.out.println("Length: " + result.length());
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        long sum = 0L; // primitive — no boxing
        for (int i = 0; i < 10_000_000; i++) {
            sum += i; // pure arithmetic, no object creation
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Sum: " + sum);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        long start = System.nanoTime();
        // 64KB buffer batches ~2,000 lines per syscall
        BufferedWriter writer = new BufferedWriter(
            new OutputStreamWriter(System.out), 65536
        );
        for (int i = 0; i < 100_000; i++) {
            writer.write("Line ");
            writer.write(String.valueOf(i));
            writer.write(": some data here");
            writer.newLine();
        }
        writer.flush();
        long elapsed = System.nanoTime() - start;
        System.err.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

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

        long start = System.nanoTime();
        // System.arraycopy is a JVM intrinsic — uses native memcpy
        int[] dest = new int[source.length];
        System.arraycopy(source, 0, dest, 0, source.length);
        long elapsed = System.nanoTime() - start;
        System.out.println("Copied: " + dest.length + " elements");
        System.out.println("Time: " + (elapsed / 1_000) + " us");
    }
}

public class Main {
    public static void main(String[] args) {
        long start = System.nanoTime();
        String[] results = new String[1_000_000];
        for (int i = 0; i < 1_000_000; i++) {
            // Simple concatenation — JIT optimizes this into StringBuilder
            results[i] = "User " + i + " logged in at " + System.nanoTime() + " ms";
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Generated: " + results.length + " messages");
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

import java.util.concurrent.atomic.LongAdder;

public class Main {
    // LongAdder uses striped cells — each thread increments its own cell
    private static final LongAdder counter = new LongAdder();

    public static void main(String[] args) throws InterruptedException {
        int threadCount = 4;
        int perThread = 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 < perThread; i++) {
                    counter.increment(); // lock-free, per-cell increment
                }
            });
            threads[t].start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Counter: " + counter.sum());
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        // Create test file
        String filename = "testfile.txt";
        FileWriter fw = new FileWriter(filename);
        for (int i = 0; i < 100_000; i++) {
            fw.write("This is line number " + i + " with some padding data\n");
        }
        fw.close();

        // Fast read: BufferedReader reads 8KB chunks, readLine() scans buffer
        long start = System.nanoTime();
        BufferedReader reader = new BufferedReader(new FileReader(filename), 65536);
        int lineCount = 0;
        while (reader.readLine() != null) {
            lineCount++;
        }
        reader.close();
        long elapsed = System.nanoTime() - start;
        System.out.println("Lines: " + lineCount);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");

        new java.io.File(filename).delete();
    }
}

public class Main {
    // final prevents subclassing — guarantees devirtualization
    static final class Adder {
        static int compute(int a, int b) {
            return a + b;
        }
    }

    public static void main(String[] args) {
        int result = 0;

        long start = System.nanoTime();
        for (int i = 0; i < 100_000_000; i++) {
            result += Adder.compute(i, 1); // static dispatch — no vtable
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Result: " + result);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

public class Main {
    static int compute(int x) {
        int result = 0;
        for (int i = 0; i < 1000; i++) {
            result += x * i + (i % 7);
        }
        return result;
    }

    // volatile prevents the JIT from eliminating the warmup computation
    static volatile int blackhole;

    public static void main(String[] args) {
        // WARMUP: trigger C2 JIT compilation
        for (int w = 0; w < 20_000; w++) {
            blackhole = compute(w);
        }

        // MEASUREMENT: JIT-compiled steady-state performance
        long start = System.nanoTime();
        int total = 0;
        for (int i = 0; i < 10_000; i++) {
            total += compute(i);
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Total: " + total);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

public class Main {
    // final class — helps JIT guarantee no subclass overrides distanceTo
    static final class Point {
        final double x, y;
        Point(double x, double y) { this.x = x; this.y = y; }
        double distanceTo(Point other) {
            double dx = this.x - other.x;
            double dy = this.y - other.y;
            return Math.sqrt(dx * dx + dy * dy);
        }
    }

    static double computeDistance(int i) {
        // No escape path — JIT performs scalar replacement
        Point a = new Point(i, i + 1);
        Point b = new Point(i + 2, i + 3);
        return a.distanceTo(b);
    }

    public static void main(String[] args) {
        // Warmup
        for (int w = 0; w < 20_000; w++) {
            computeDistance(w);
        }

        long start = System.nanoTime();
        double total = 0;
        for (int i = 0; i < 10_000_000; i++) {
            total += computeDistance(i);
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Total: " + total);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

public class Main {
    static int parseOrDefault(String s, int defaultVal) {
        // Pre-validate: check if string is a valid integer before parsing
        if (s == null || s.isEmpty()) return defaultVal;
        int start = 0;
        if (s.charAt(0) == '-' || s.charAt(0) == '+') {
            if (s.length() == 1) return defaultVal;
            start = 1;
        }
        for (int i = start; i < s.length(); i++) {
            if (s.charAt(i) < '0' || s.charAt(i) > '9') {
                return defaultVal; // not a digit — return default without exception
            }
        }
        // Safe to parse — we know it's a valid integer string
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return defaultVal; // overflow edge case
        }
    }

    public static void main(String[] args) {
        String[] data = new String[1_000_000];
        for (int i = 0; i < data.length; i++) {
            data[i] = (i % 2 == 0) ? String.valueOf(i) : "not_a_number";
        }

        // Warmup
        for (int w = 0; w < 20_000; w++) {
            parseOrDefault(data[w % data.length], -1);
        }

        long start = System.nanoTime();
        long sum = 0;
        for (String s : data) {
            sum += parseOrDefault(s, 0);
        }
        long elapsed = System.nanoTime() - start;
        System.out.println("Sum: " + sum);
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}