Java Generics Deep Dive — Type Erasure, Wildcards and Production Pitfalls

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class TypeErasureDemo {

    // A generic method — at compile time T is known, at runtime it's erased
    public static <T extends Number> double sumList(List<T> numbers) {
        double total = 0.0;
        for (T number : numbers) {
            // After erasure this loop variable is typed as Number (the upper bound)
            // The compiler already inserted a hidden cast here for safety
            total += number.doubleValue();
        }
        return total;
    }

    public static void main(String[] args) throws Exception {
        List<Integer> integerList = new ArrayList<>();
        integerList.add(10);
        integerList.add(20);
        integerList.add(30);

        List<Double> doubleList = new ArrayList<>();
        doubleList.add(1.5);
        doubleList.add(2.5);

        System.out.println("Sum of integers: " + sumList(integerList)); // 60.0
        System.out.println("Sum of doubles: " + sumList(doubleList));   // 4.0

        // PROOF of type erasure: both lists report the same runtime class
        System.out.println("integerList class: " + integerList.getClass().getName());
        System.out.println("doubleList class:  " + doubleList.getClass().getName());
        System.out.println("Same class? " + (integerList.getClass() == doubleList.getClass()));

        // Reflection lets us peek at what the compiler stored about generic types
        // (via the signature attribute — NOT actual runtime type params)
        Method sumMethod = TypeErasureDemo.class.getMethod("sumList", List.class);
        System.out.println("\nMethod generic return type: " + sumMethod.getGenericReturnType());
        System.out.println("Erased parameter type:      " + sumMethod.getParameterTypes()[0].getName());

        // This would compile but is DANGEROUS — raw type bypasses all generic safety
        List rawList = integerList;  // unchecked assignment, compiler warns
        rawList.add("oops");         // compiler can't stop this on a raw type!
        // Reading back would throw ClassCastException at runtime — erasure's dark side
        // (We don't read back here to avoid crashing the demo)
        System.out.println("\nRaw list size after sneaking a String in: " + rawList.size());
    }
}

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

public class PECSDemo {

    /**
     * PRODUCER — reads from source and sums values.
     * Uses '? extends Number' because source PRODUCES Numbers for us to read.
     * We never write back to source, so this is safe for List<Integer>, List<Double>, etc.
     */
    public static double sumProducer(List<? extends Number> source) {
        double total = 0.0;
        for (Number value : source) {   // safe read — every element IS-A Number
            total += value.doubleValue();
        }
        // source.add(1.0); // COMPILE ERROR — can't write, don't know exact subtype
        return total;
    }

    /**
     * CONSUMER — writes values into a destination list.
     * Uses '? super Integer' because destination CONSUMES Integers we push in.
     * Works for List<Integer>, List<Number>, List<Object>.
     */
    public static void fillWithSquares(List<? super Integer> destination, int count) {
        for (int i = 1; i <= count; i++) {
            destination.add(i * i);  // safe write — destination can hold at least Integer
        }
        // Integer top = destination.get(0); // COMPILE ERROR — reads only give us Object
    }

    /**
     * A real-world PECS use case: copy from a producer into a consumer.
     * This is exactly how Collections.copy() in the JDK is implemented.
     */
    public static <T> void copyElements(List<? extends T> source, List<? super T> destination) {
        for (T element : source) {
            destination.add(element);  // read from producer, write to consumer
        }
    }

    public static void main(String[] args) {
        // Producer side
        List<Integer> scores = List.of(4, 9, 16, 25);
        List<Double>  prices = List.of(1.99, 3.49, 7.00);
        System.out.println("Sum of scores: " + sumProducer(scores)); // works with Integer list
        System.out.println("Sum of prices: " + sumProducer(prices)); // works with Double list

        // Consumer side
        List<Number> numberBucket = new ArrayList<>();
        fillWithSquares(numberBucket, 5);  // List<Number> can consume Integer writes
        System.out.println("Squares in Number bucket: " + numberBucket);

        List<Object> objectBucket = new ArrayList<>();
        fillWithSquares(objectBucket, 3);  // List<Object> also works — super of Integer
        System.out.println("Squares in Object bucket: " + objectBucket);

        // Copy using combined producer+consumer
        List<Integer> sourceInts = new ArrayList<>(List.of(100, 200, 300));
        List<Number>  targetNums = new ArrayList<>();
        copyElements(sourceInts, targetNums);  // Integer extends Number, Number super Integer
        System.out.println("Copied elements: " + targetNums);
    }
}

import java.util.*;
import java.util.function.Supplier;

/**
 * A generic cache that stores Identifiable items keyed by their natural ID.
 * T must be Identifiable AND Comparable so we can support sorted retrieval.
 * This demonstrates: multiple bounds, recursive type bounds, Supplier for instantiation.
 */
public class BoundedGenericCache<T extends Identifiable & Comparable<T>> {

    // The backing store — a TreeMap keeps entries sorted by key
    private final Map<String, T> store = new TreeMap<>();

    // Maximum number of items this cache can hold
    private final int maxCapacity;

    public BoundedGenericCache(int maxCapacity) {
        this.maxCapacity = maxCapacity;
    }

    /** Adds an item if the cache isn't full. Returns true if the item was added. */
    public boolean put(T item) {
        if (store.size() >= maxCapacity) {
            System.out.println("Cache full — rejecting: " + item.getId());
            return false;
        }
        store.put(item.getId(), item);
        return true;
    }

    /** Retrieves by ID. Returns Optional so callers handle missing entries safely. */
    public Optional<T> get(String id) {
        return Optional.ofNullable(store.get(id));
    }

    /**
     * Returns all cached items in their natural sorted order.
     * Because T extends Comparable<T> we can sort without a Comparator.
     */
    public List<T> getAllSorted() {
        List<T> items = new ArrayList<>(store.values());
        Collections.sort(items);  // uses T's compareTo — safe because of the bound
        return Collections.unmodifiableList(items);
    }

    /**
     * Demonstrates using Supplier<T> to create instances without 'new T()'.
     * This is the clean pattern when you need factory-style construction.
     */
    public static <T extends Identifiable & Comparable<T>>
            BoundedGenericCache<T> createWithDefaults(int capacity, Supplier<T[]> defaultsSupplier) {
        BoundedGenericCache<T> cache = new BoundedGenericCache<>(capacity);
        for (T item : defaultsSupplier.get()) {
            cache.put(item);
        }
        return cache;
    }

    // ── Inner types to make this self-contained ──────────────────────────────

    interface Identifiable {
        String getId();
    }

    static class Product implements Identifiable, Comparable<Product> {
        private final String id;
        private final String name;
        private final double price;

        Product(String id, String name, double price) {
            this.id    = id;
            this.name  = name;
            this.price = price;
        }

        @Override public String getId()   { return id; }

        // Natural order: sort by price ascending
        @Override public int compareTo(Product other) {
            return Double.compare(this.price, other.price);
        }

        @Override public String toString() {
            return String.format("Product{id='%s', name='%s', price=%.2f}", id, name, price);
        }
    }

    // ── Main demo ────────────────────────────────────────────────────────────

    public static void main(String[] args) {
        // Create a cache using the Supplier factory method
        BoundedGenericCache<Product> productCache = BoundedGenericCache.createWithDefaults(
            3,
            () -> new Product[] {
                new Product("P001", "Keyboard", 79.99),
                new Product("P002", "Monitor",  349.00),
                new Product("P003", "Mouse",     39.95)
            }
        );

        // Try adding a 4th item — should be rejected (capacity = 3)
        productCache.put(new Product("P004", "Webcam", 89.00));

        // Retrieve by ID using Optional — no raw null checks
        productCache.get("P002").ifPresentOrElse(
            p -> System.out.println("Found: " + p),
            ()  -> System.out.println("Not found")
        );

        // Print all sorted by price (cheapest first)
        System.out.println("\nAll products sorted by price:");
        productCache.getAllSorted().forEach(System.out::println);
    }
}

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

public class HeapPollutionDemo {

    /**
     * UNSAFE varargs method — DO NOT copy this pattern.
     * It stores the varargs array reference, which causes heap pollution.
     * The compiler warning here is a genuine red flag, not noise.
     */
    @SuppressWarnings("unchecked") // suppressed to show the pollution effect explicitly
    static <T> List<T>[] unsafeGrouping(List<T>... groups) {
        // Storing the array reference is what makes this dangerous
        Object[] rawArray = groups;       // legal — arrays are covariant
        rawArray[0] = List.of(42, 99);   // we just stuffed Integers into a List<String> slot!
        return groups;                    // caller gets a corrupted array back
    }

    /**
     * SAFE alternative using @SafeVarargs.
     * We only READ from the varargs array — we never store or leak the array reference.
     * This is the contract that @SafeVarargs represents.
     */
    @SafeVarargs // safe because we don't store the array or write to it
    static <T> List<T> mergeLists(List<T>... lists) {
        List<T> merged = new ArrayList<>();
        for (List<T> list : lists) {  // only iterating — no array reference stored
            merged.addAll(list);
        }
        return merged;
    }

    /**
     * Why generic arrays are illegal — illustrated safely.
     * List<String>[] stringLists = new List<String>[3]; // COMPILE ERROR
     * But List<?>[] works because List<?> is reifiable (unbounded wildcard).
     */
    static void reifiableVsNonReifiable() {
        // Reifiable — these all retain full type info at runtime
        String[]  stringArray  = new String[5];   // OK — String is reifiable
        List<?>[] wildcardLists = new List<?>[3]; // OK — List<?> is reifiable

        // Non-reifiable — compiler stops you from creating these arrays
        // List<String>[] typedLists = new List<String>[3]; // COMPILE ERROR
        // T[] genericArray = new T[5];                     // COMPILE ERROR in generic class

        System.out.println("String array type:   " + stringArray.getClass().getComponentType());
        System.out.println("Wildcard array type: " + wildcardLists.getClass().getComponentType());
    }

    public static void main(String[] args) {
        // Demonstrate SAFE merge — no warnings, no surprises
        List<String> fruits     = List.of("apple", "banana");
        List<String> vegetables = List.of("carrot", "spinach");
        List<String> allFood    = mergeLists(fruits, vegetables);
        System.out.println("Merged list: " + allFood);

        // Demonstrate heap pollution effect
        List<String>[] groups = unsafeGrouping(new ArrayList<>(List.of("hello")));
        // groups[0] now secretly holds a List<Integer> — heap is polluted!
        try {
            // ClassCastException fires HERE — not where the bad write happened
            String value = groups[0].get(0); // runtime tries to cast Integer to String
            System.out.println("Got (should not reach): " + value);
        } catch (ClassCastException e) {
            System.out.println("Heap pollution caught: " + e.getMessage());
            System.out.println("Notice: the cast code isn't even visible in OUR source!");
        }

        System.out.println();
        reifiableVsNonReifiable();
    }
}