Data Types — Optimize the Code¶

public class FastSum {
    public static long calculateSum() {
        long sum = 0L;     // primitive long — no boxing
        for (int i = 0; i < 1_000_000; i++) {  // primitive int
            sum += i;
        }
        return sum;
    }

    public static void main(String[] args) {
        long result = calculateSum();
        System.out.println("Sum: " + result);
    }
}

public class FastTemperature {
    public static double averageTemperature(int[] readings) {
        long sum = 0;
        for (int reading : readings) {
            sum += reading; // no unboxing needed
        }
        return (double) sum / readings.length;
    }

    public static void main(String[] args) {
        int[] readings = new int[1_000_000];
        for (int i = 0; i < readings.length; i++) {
            readings[i] = 20 + (i % 30); // no autoboxing
        }
        System.out.println("Average: " + averageTemperature(readings));
    }
}

import java.util.StringJoiner;

public class FastCsv {
    public static String buildCsv(int[] values) {
        StringJoiner joiner = new StringJoiner(",");
        for (int value : values) {
            joiner.add(String.valueOf(value));
        }
        return joiner.toString();
    }

    public static void main(String[] args) {
        int[] values = new int[10_000];
        for (int i = 0; i < values.length; i++) values[i] = i;
        System.out.println(buildCsv(values).substring(0, 50) + "...");
    }
}

public class FastFrequency {
    public static int[] countFrequency(int[] data, int maxValue) {
        int[] freq = new int[maxValue + 1]; // direct-indexed "map"
        for (int value : data) {
            freq[value]++;
        }
        return freq;
    }

    public static void main(String[] args) {
        int[] data = new int[5_000_000];
        for (int i = 0; i < data.length; i++) {
            data[i] = i % 1000;
        }
        int[] freq = countFrequency(data, 999);
        System.out.println("Freq of 0: " + freq[0]);
    }
}

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public class FastInterest {
    private static final MathContext MC = new MathContext(10, RoundingMode.HALF_UP);

    public static BigDecimal calculateCompoundInterest(
            String principal, String rate, int years) {
        BigDecimal balance = new BigDecimal(principal);            // String constructor
        BigDecimal annualRate = BigDecimal.ONE.add(new BigDecimal(rate)); // String constructor

        for (int i = 0; i < years; i++) {
            balance = balance.multiply(annualRate, MC); // bounded precision
        }
        return balance.setScale(2, RoundingMode.HALF_UP);
    }

    public static void main(String[] args) {
        BigDecimal result = calculateCompoundInterest("1000.00", "0.05", 100);
        System.out.println("Final balance: $" + result);
    }
}

import java.util.stream.IntStream;

public class FastPipeline {
    public static long processData(int size) {
        return IntStream.range(0, size)
            .filter(n -> n % 2 == 0)        // no boxing — int throughout
            .mapToLong(n -> (long) n * n)    // int to long, no boxing
            .filter(n -> n > 100)            // long comparison, no boxing
            .sum();
    }

    public static void main(String[] args) {
        System.out.println("Result: " + processData(10_000_000));
    }
}

public class FastRangeChecker {
    private final int min;
    private final int max;

    public FastRangeChecker(String minStr, String maxStr) {
        this.min = Integer.parseInt(minStr);  // parse once
        this.max = Integer.parseInt(maxStr);  // parse once
    }

    public boolean isInRange(int value) {
        return value >= min && value <= max;  // pure primitive comparison
    }

    public static void main(String[] args) {
        FastRangeChecker checker = new FastRangeChecker("0", "1000");
        int count = 0;
        for (int i = 0; i < 10_000_000; i++) {
            if (checker.isInRange(i % 2000)) count++;
        }
        System.out.println("In range: " + count);
    }
}

public class FastBuffer {
    public static byte[] allocateImageBuffer(int width, int height, int channels) {
        // Validate inputs
        if (width <= 0 || height <= 0 || channels <= 0) {
            throw new IllegalArgumentException("Dimensions must be positive");
        }

        // Overflow-safe calculation using long
        long size;
        try {
            size = Math.multiplyExact((long) width, height);
            size = Math.multiplyExact(size, channels);
        } catch (ArithmeticException e) {
            throw new IllegalArgumentException(
                String.format("Image too large: %dx%dx%d", width, height, channels), e);
        }

        // Check array size limit
        if (size > Integer.MAX_VALUE) {
            throw new IllegalArgumentException(
                "Buffer size exceeds max array size: " + size + " bytes");
        }

        return new byte[(int) size];
    }

    public static void main(String[] args) {
        byte[] small = allocateImageBuffer(1920, 1080, 4);
        System.out.println("Small buffer: " + small.length + " bytes");

        try {
            byte[] large = allocateImageBuffer(50000, 50000, 4);
        } catch (IllegalArgumentException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

import java.util.HashSet;
import java.util.Set;

public class FastCollect {
    public static Set<Integer> collectUniqueIds(int totalRecords) {
        int expectedUnique = totalRecords / 2;

        // Pre-size HashSet: capacity = expected / load_factor + 1
        Set<Integer> uniqueIds = new HashSet<>((int)(expectedUnique / 0.75) + 1);

        // Skip the ArrayList entirely — we don't need it
        for (int i = 0; i < totalRecords; i++) {
            int id = i % expectedUnique;
            uniqueIds.add(id);
        }

        return uniqueIds;
    }

    public static void main(String[] args) {
        Set<Integer> result = collectUniqueIds(2_000_000);
        System.out.println("Unique: " + result.size());
    }
}

import java.util.Arrays;
import java.util.Random;

public class FastSearch {
    public static int findId(int[] ids, int target) {
        Arrays.sort(ids);                      // sorts primitives — no boxing
        return Arrays.binarySearch(ids, target); // primitive comparison
    }

    public static void main(String[] args) {
        int[] ids = new int[5_000_000];
        Random random = new Random(42);
        for (int i = 0; i < ids.length; i++) {
            ids[i] = random.nextInt(10_000_000); // no autoboxing
        }

        long start = System.nanoTime();
        int index = findId(ids, 5_000_000);
        long elapsed = (System.nanoTime() - start) / 1_000_000;
        System.out.println("Found at index: " + index + " in " + elapsed + " ms");
    }
}