Java Generics — Heap Pollution from Raw Type Corruption

package io.thecodeforge.generics;

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());
    }
}

package io.thecodeforge.generics;

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);
    }
}

package io.thecodeforge.collections;

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);
    }
}

package io.thecodeforge.generics;

// A simple generic interface representing a container that can hold a value
interface Container<T> {
    void put(T value);
    T get();
    boolean isEmpty();
}

// Implementation that fixes the type argument to String
class StringContainer implements Container<String> {
    private String value;

    @Override
    public void put(String value) { this.value = value; }

    @Override
    public String get() { return value; }

    @Override
    public boolean isEmpty() { return value == null; }
}

// Generic implementation — Container remains parameterized
class GenericHolder<E> implements Container<E> {
    private E element;

    @Override
    public void put(E element) { this.element = element; }

    @Override
    public E get() { return element; }

    @Override
    public boolean isEmpty() { return element == null; }
}

// An interface with multiple type parameters (like Map.Entry)
interface Pair<A, B> {
    A getFirst();
    B getSecond();
}

class OrderedPair<X, Y> implements Pair<X, Y> {
    private final X first;
    private final Y second;

    public OrderedPair(X first, Y second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public X getFirst() { return first; }

    @Override
    public Y getSecond() { return second; }
}

// Usage
public class GenericInterfaceDemo {
    public static void main(String[] args) {
        Container<String> c1 = new StringContainer();
        c1.put("Hello");
        System.out.println(c1.get());             // Hello

        Container<Integer> c2 = new GenericHolder<>();
        c2.put(42);
        System.out.println(c2.get());             // 42

        Pair<String, Integer> p = new OrderedPair<>("Age", 30);
        System.out.println(p.getFirst() + ": " + p.getSecond());
    }
}

package io.thecodeforge.generics;

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();
    }
}

package io.thecodeforge.generics;

import java.util.*;

public class RecursiveBoundDemo {

    // A generic method that finds the maximum in a collection using recursive bound
    public static <T extends Comparable<T>> T max(Collection<T> coll) {
        T max = coll.iterator().next();
        for (T elem : coll) {
            if (elem.compareTo(max) > 0) {
                max = elem;
            }
        }
        return max;
    }

    // Example with CRTP: abstract class that returns 'this' typed as the subclass
    abstract static class AbstractEntity<T extends AbstractEntity<T>> {
        private long id;
        public T withId(long id) {
            this.id = id;
            return self();
        }
        protected abstract T self();
    }

    static class User extends AbstractEntity<User> {
        @Override
        protected User self() { return this; }
    }

    public static void main(String[] args) {
        // Using recursive bound max
        List<String> words = List.of("apple", "banana", "cherry");
        System.out.println("Max: " + max(words)); // cherry

        // Fluent API with CRTP
        User user = new User().withId(42L);
        System.out.println("User ID: " + user.withId(1L)); // User{id=1}
    }
}

package io.thecodeforge.generics;

import java.util.*;
import java.util.function.Predicate;

public class GenericsPracticeProblems {

    // Problem 1: Generic Stack
    static class Stack<T> {
        private final List<T> elements = new ArrayList<>();

        public void push(T item) { elements.add(item); }

        public T pop() {
            if (isEmpty()) throw new EmptyStackException();
            return elements.remove(elements.size() - 1);
        }

        public T peek() {
            if (isEmpty()) throw new EmptyStackException();
            return elements.get(elements.size() - 1);
        }

        public boolean isEmpty() { return elements.isEmpty(); }
    }

    // Problem 2: Generic Pair
    static class Pair<K, V> {
        private final K first;
        private final V second;

        private Pair(K first, V second) {
            this.first = first;
            this.second = second;
        }

        public static <K, V> Pair<K, V> of(K first, V second) {
            return new Pair<>(first, second);
        }

        public K getFirst() { return first; }
        public V getSecond() { return second; }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Pair)) return false;
            Pair<?, ?> pair = (Pair<?, ?>) o;
            return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
        }

        @Override
        public int hashCode() {
            return Objects.hash(first, second);
        }
    }

    // Problem 3: Bounded Search Method
    public static <T extends Comparable<T>> Optional<T> findFirst(List<T> list, Predicate<T> predicate) {
        for (T item : list) {
            if (predicate.test(item)) {
                return Optional.of(item);
            }
        }
        return Optional.empty();
    }

    // Problem 4: Unbounded Wildcard Printer
    public static void printList(List<?> list) {
        for (Object elem : list) {
            System.out.println(elem);
        }
    }

    // Problem 5: Factory with Class<T> token
    static class Factory<T> {
        private final Class<T> clazz;

        public Factory(Class<T> clazz) { this.clazz = clazz; }

        public T create() {
            try {
                return clazz.getDeclaredConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("Failed to create instance of " + clazz.getName(), e);
            }
        }
    }

    // Demo of solutions
    public static void main(String[] args) {
        // Problem 1: Stack
        Stack<String> stringStack = new Stack<>();
        stringStack.push("first");
        stringStack.push("second");
        System.out.println(stringStack.pop()); // second

        // Problem 2: Pair
        Pair<Integer, String> pair = Pair.of(1, "one");
        System.out.println(pair.getFirst()); // 1

        // Problem 3: findFirst
        List<Integer> numbers = List.of(5, 12, 3, 8);
        Optional<Integer> found = findFirst(numbers, n -> n > 10);
        System.out.println(found.orElse(null)); // 12

        // Problem 4: printList works with any list
        printList(List.of("hello", 42, 3.14));

        // Problem 5: Factory
        Factory<StringBuilder> factory = new Factory<>(StringBuilder.class);
        StringBuilder sb = factory.create();
        sb.append("Built via reflection");
        System.out.println(sb);
    }
}

package io.thecodeforge.generics;

import java.util.*;
import java.util.stream.*;

public class Java8TypeInference {

    public static void main(String[] args) {
        // Before Java 8: had to specify type witnesses
        List<String> oldWay = Collections.<String>emptyList();
        Map<String, Integer> oldMap = new HashMap<String, Integer>();

        // Java 8+: inference from target type
        List<String> newWay = Collections.emptyList();        // inferred from variable type
        Map<String, Integer> newMap = new HashMap<>();        // diamond operator

        // Inference in method chaining
        Optional<String> result = Optional.of("hello").map(String::toUpperCase).filter(s -> s.startsWith("H"));
        System.out.println(result.orElse("not found"));      // HELLO

        // Inference with generics and streams
        List<Integer> numbers = Stream.of(1, 2, 3)
            .filter(n -> n > 1)
            .map(n -> n * 10)
            .collect(Collectors.toList());    // types inferred from stream pipeline
        System.out.println(numbers);                         // [20, 30]

        // When inference fails: ambiguous equality constraints
        // List.of(1, 2, "three") would not compile because of mixed types — that's the compiler protecting you

        // Complex nested generics may still need explicit type hints
        // Map<String, List<Optional<Integer>>> complex = new HashMap<>(); // works
        // But sometimes you need to help: Collections.<String, List<Integer>>emptyMap();
    }
}

// io.thecodeforge
import java.util.*;

public class LegacyCastingBug {
    public static void main(String[] args) {
        // Pre-generics: raw type, everyone suffers
        List rawList = new ArrayList();
        rawList.add("Hello");
        rawList.add(42);  // Legal, because everything is Object

        // Somewhere else in the codebase...
        for (Object item : rawList) {
            String str = (String) item;  // BOOM at runtime on 42
            System.out.println(str.toUpperCase());
        }
    }
}

// io.thecodeforge
public class GenericLimitationsDemo<T> {

    // ERROR: Cannot instantiate type parameter
    // private T instance = new T();  // won't compile

    // ERROR: static field of type T
    // private static T staticField;  // won't compile

    // Workaround: factory pattern with Class<T>
    public GenericLimitationsDemo(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        System.out.println("Created: " + instance.getClass().getSimpleName());
    }

    // Primitive workaround: use wrapper
    public static void main(String[] args) throws Exception {
        // List<int> ints = new ArrayList<>();  // won't compile
        new GenericLimitationsDemo<>(String.class);
    }
}