Data Types — Senior Level¶

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
public class AutoboxingBenchmark {

    private static final int SIZE = 1_000_000;

    @Benchmark
    public long sumBoxed() {
        Long sum = 0L;
        for (int i = 0; i < SIZE; i++) {
            sum += i; // autoboxing every iteration
        }
        return sum;
    }

    @Benchmark
    public long sumPrimitive() {
        long sum = 0L;
        for (int i = 0; i < SIZE; i++) {
            sum += i;
        }
        return sum;
    }
}

// The JIT can optimize this — Integer doesn't escape
public int compute(int x) {
    Integer temp = x * 2;  // JIT may eliminate this allocation
    return temp + 1;       // scalar replacement: treats as int
}

// The JIT CANNOT optimize this — Integer escapes via return
public Integer computeBoxed(int x) {
    Integer temp = x * 2;  // must allocate — escapes method
    return temp;
}

// Future Java syntax (preview)
value class Point {
    int x;
    int y;
}
// No identity, no header overhead, stack-allocated
// Point[] would be flat array, not array of pointers

import java.util.Arrays;

/**
 * A fixed-capacity int set using open addressing.
 * Avoids autoboxing entirely — O(1) add/contains.
 */
public class PrimitiveIntSet {
    private static final int EMPTY = Integer.MIN_VALUE;
    private final int[] table;
    private int size;

    public PrimitiveIntSet(int capacity) {
        // Power of 2 for fast modulus
        int realCapacity = Integer.highestOneBit(capacity - 1) << 1;
        this.table = new int[realCapacity];
        Arrays.fill(table, EMPTY);
    }

    public boolean add(int value) {
        if (value == EMPTY) throw new IllegalArgumentException("Reserved sentinel value");
        int idx = value & (table.length - 1);
        while (table[idx] != EMPTY) {
            if (table[idx] == value) return false; // already exists
            idx = (idx + 1) & (table.length - 1);
        }
        table[idx] = value;
        size++;
        return true;
    }

    public boolean contains(int value) {
        if (value == EMPTY) return false;
        int idx = value & (table.length - 1);
        while (table[idx] != EMPTY) {
            if (table[idx] == value) return true;
            idx = (idx + 1) & (table.length - 1);
        }
        return false;
    }

    public int size() { return size; }

    public static void main(String[] args) {
        PrimitiveIntSet set = new PrimitiveIntSet(1024);
        for (int i = 0; i < 500; i++) set.add(i);
        System.out.println("Size: " + set.size());           // 500
        System.out.println("Contains 42: " + set.contains(42)); // true
        System.out.println("Contains 999: " + set.contains(999)); // false
    }
}

/**
 * Strongly-typed ID wrapper — prevents mixing user IDs with order IDs.
 * Uses record (Java 16+) for zero boilerplate.
 */
public class Main {
    public record UserId(long value) {
        public UserId {
            if (value <= 0) throw new IllegalArgumentException("UserId must be positive");
        }
    }

    public record OrderId(long value) {
        public OrderId {
            if (value <= 0) throw new IllegalArgumentException("OrderId must be positive");
        }
    }

    static void processOrder(OrderId orderId, UserId userId) {
        System.out.printf("Processing order %d for user %d%n", orderId.value(), userId.value());
    }

    public static void main(String[] args) {
        UserId userId = new UserId(42L);
        OrderId orderId = new OrderId(1001L);

        processOrder(orderId, userId); // correct
        // processOrder(userId, orderId); // COMPILE ERROR — type safety!
    }
}

/**
 * Custom flyweight cache extending beyond Integer's default -128..127.
 * Useful when your domain has a known range of frequently-used values.
 */
public class Main {
    private static final int CACHE_LOW = 0;
    private static final int CACHE_HIGH = 10_000;
    private static final Integer[] CACHE = new Integer[CACHE_HIGH - CACHE_LOW + 1];

    static {
        for (int i = CACHE_LOW; i <= CACHE_HIGH; i++) {
            CACHE[i - CACHE_LOW] = Integer.valueOf(i);
        }
    }

    public static Integer cachedValueOf(int value) {
        if (value >= CACHE_LOW && value <= CACHE_HIGH) {
            return CACHE[value - CACHE_LOW];
        }
        return Integer.valueOf(value);
    }

    public static void main(String[] args) {
        Integer a = cachedValueOf(5000);
        Integer b = cachedValueOf(5000);
        System.out.println(a == b);     // true — same cached instance
        System.out.println(a.equals(b)); // true
    }
}

import java.util.OptionalInt;

public class Main {
    // Null Object pattern — return OptionalInt instead of nullable Integer
    static OptionalInt findAge(String userId) {
        // Simulating nullable database result
        Integer dbResult = null; // from ResultSet.getObject("age", Integer.class)
        return (dbResult != null) ? OptionalInt.of(dbResult) : OptionalInt.empty();
    }

    public static void main(String[] args) {
        OptionalInt age = findAge("user123");

        // No NPE risk — explicit handling
        int finalAge = age.orElse(0);
        System.out.println("Age: " + finalAge);

        age.ifPresent(a -> System.out.println("Found age: " + a));
    }
}

public class Main {
    // Overloaded APIs: primitive for performance, wrapper for nullable
    public static int add(int a, int b) {
        return Math.addExact(a, b); // primitive path — fast
    }

    public static Integer add(Integer a, Integer b) {
        if (a == null || b == null) return null; // nullable path
        return add(a.intValue(), b.intValue());  // delegate to primitive
    }

    public static void main(String[] args) {
        System.out.println(add(5, 3));              // 8 (primitive path)
        System.out.println(add(Integer.valueOf(5), null)); // null (wrapper path)
    }
}

// ❌ Primitives leaking across service boundaries (ambiguous nullability)
public class UserService {
    public int getAge(long userId) {
        // What if user not found? Return 0? -1? Throw?
        return 0; // ambiguous!
    }
}

// ✅ Clear type contracts at each layer
// Repository layer: nullable wrappers (database can have NULLs)
public interface UserRepository {
    Integer findAge(Long userId); // nullable — matches DB column
}

// Service layer: Optional (explicit absence)
public class UserService {
    private final UserRepository repo;

    public UserService(UserRepository repo) { this.repo = repo; }

    public OptionalInt findAge(long userId) {
        Integer age = repo.findAge(userId);
        return (age != null) ? OptionalInt.of(age) : OptionalInt.empty();
    }
}

// Controller layer: default value for API response
// @GetMapping("/users/{id}/age")
// public int getAge(@PathVariable long id) {
//     return userService.findAge(id).orElse(0);
// }

public class SafeMath {
    /**
     * Multiplies two values with overflow detection.
     * Used in buffer size calculations where overflow = security vulnerability.
     */
    public static int safeMultiply(int a, int b) {
        try {
            return Math.multiplyExact(a, b);
        } catch (ArithmeticException e) {
            throw new IllegalArgumentException(
                String.format("Multiplication overflow: %d * %d", a, b), e);
        }
    }

    /**
     * Adds two values with overflow detection.
     */
    public static long safeAdd(long a, long b) {
        try {
            return Math.addExact(a, b);
        } catch (ArithmeticException e) {
            throw new IllegalArgumentException(
                String.format("Addition overflow: %d + %d", a, b), e);
        }
    }

    public static void main(String[] args) {
        System.out.println(safeMultiply(100, 200));     // 20000
        // safeMultiply(Integer.MAX_VALUE, 2);           // throws IllegalArgumentException
    }
}

// ❌ Vulnerable — attacker controls width and height via API
public byte[] createImage(int width, int height) {
    int size = width * height * 4; // RGBA — can overflow!
    return new byte[size];         // negative size or tiny allocation
}

// ✅ Secure — validate and use exact arithmetic
public byte[] createImageSafe(int width, int height) {
    if (width <= 0 || height <= 0) {
        throw new IllegalArgumentException("Dimensions must be positive");
    }
    if (width > 10_000 || height > 10_000) {
        throw new IllegalArgumentException("Image too large");
    }
    long size = (long) width * height * 4; // promote to long before multiply
    if (size > Integer.MAX_VALUE) {
        throw new IllegalArgumentException("Image size exceeds maximum");
    }
    return new byte[(int) size];
}

import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.List;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        int size = 10_000_000;
        List<Integer> numbers = new ArrayList<>(size);
        for (int i = 0; i < size; i++) numbers.add(i);

        // ❌ Slow — Stream<Integer> boxes/unboxes
        long start1 = System.nanoTime();
        long sum1 = numbers.stream()
            .filter(n -> n % 2 == 0)      // unboxing for %
            .mapToLong(n -> (long) n * n)  // unboxing for *
            .sum();
        long time1 = System.nanoTime() - start1;

        // ✅ Fast — IntStream, no boxing
        long start2 = System.nanoTime();
        long sum2 = IntStream.range(0, size)
            .filter(n -> n % 2 == 0)
            .mapToLong(n -> (long) n * n)
            .sum();
        long time2 = System.nanoTime() - start2;

        System.out.printf("Stream<Integer>: %d ms%n", time1 / 1_000_000);
        System.out.printf("IntStream:       %d ms%n", time2 / 1_000_000);
    }
}

// Add NaN guard at computation boundary
public double computeRatio(double numerator, double denominator) {
    double result = numerator / denominator;
    if (Double.isNaN(result) || Double.isInfinite(result)) {
        log.warn("Invalid ratio: {}/{} = {}", numerator, denominator, result);
        return 0.0; // or throw
    }
    return result;
}

public class Main {
    public static void main(String[] args) {
        // This behavior CHANGES with JVM flags!
        Integer a = 200;
        Integer b = 200;
        System.out.println(a == b); // false (default)
        // With -XX:AutoBoxCacheMax=300 -> true

        // NEVER rely on == for wrapper comparison
    }
}

public class Main {
    public static void main(String[] args) {
        long nowMs = System.currentTimeMillis();
        // ❌ Overflow: int literal 24 * 60 * ... is computed as int before promotion
        long oneDayMs = 24 * 60 * 60 * 1000; // OK — fits in int (86_400_000)
        long oneYearMs = 365 * 24 * 60 * 60 * 1000; // OVERFLOW! 31_536_000_000 > Integer.MAX_VALUE

        System.out.println("One year ms (buggy): " + oneYearMs);  // 1_471_228_928 (wrong!)
        System.out.println("One year ms (correct): " + (365L * 24 * 60 * 60 * 1000)); // 31_536_000_000

        // ✅ Fix: make the first operand long
        long correctOneYear = 365L * 24 * 60 * 60 * 1000;
        System.out.println("Correct: " + correctOneYear);
    }
}

// ❌ Ambiguous — is 0 a valid result or "not found"?
public int findUserAge(long userId) {
    User user = userRepository.findById(userId).orElse(null);
    return (user != null) ? user.getAge() : 0; // 0 = not found? or 0 years old?
}

// ✅ Explicit contract
public OptionalInt findUserAge(long userId) {
    return userRepository.findById(userId)
        .map(User::getAge)
        .map(OptionalInt::of)
        .orElse(OptionalInt.empty());
}

public class Main {
    public static void main(String[] args) {
        byte b = 100;
        // b = b + 1;   // COMPILE ERROR: int cannot be assigned to byte
        b += 1;          // COMPILES: compound assignment includes implicit cast
        // Equivalent to: b = (byte)(b + 1);

        // This can silently overflow:
        b = 127;
        b += 1;
        System.out.println(b); // -128 (overflow, no error!)
    }
}

public class Main {
    public static void main(String[] args) {
        char c = 'A';
        // Ternary promotes char to int when one branch is int
        System.out.println(true ? c : 0);   // A (char)
        int zero = 0;
        System.out.println(true ? c : zero); // 65 (int — promoted because zero is int variable!)
    }
}

public Map<Integer, Double> calculateAverages(List<Integer> sensorIds, List<Double> readings) {
    Map<Integer, Double> sums = new HashMap<>();
    Map<Integer, Integer> counts = new HashMap<>();
    for (int i = 0; i < sensorIds.size(); i++) {
        Integer id = sensorIds.get(i);
        sums.merge(id, readings.get(i), Double::sum);
        counts.merge(id, 1, Integer::sum);
    }
    Map<Integer, Double> averages = new HashMap<>();
    for (Integer id : sums.keySet()) {
        averages.put(id, sums.get(id) / counts.get(id));
    }
    return averages;
}

Float f1 = Float.NaN;
Float f2 = Float.NaN;
System.out.println(f1.equals(f2));
System.out.println(f1.compareTo(f2));
System.out.println(f1 == f1);
System.out.println(Float.NaN == Float.NaN);

public long compute(List<Integer> list) {
    long sum = 0;
    for (Integer val : list) {
        sum += val;  // unboxing
    }
    return sum;
}