Java Generics

import java.util.Arrays;

public class Main {
    // 1. Generic class — T is a placeholder, filled in when you create a Box.
    static class Box<T> {
        private T content;
        void set(T item) { content = item; }   // accepts only a T
        T get() { return content; }             // returns a T — no cast needed
        @Override public String toString() { return "Box[" + content + "]"; }
    }

    // 2. Two type parameters: K (key) and V (value).
    static class Pair<K, V> {
        final K key;
        final V value;
        Pair(K key, V value) { this.key = key; this.value = value; }
        @Override public String toString() { return "(" + key + " -> " + value + ")"; }
    }

    public static void main(String[] args) {
        // A Box<String> can ONLY hold Strings.
        Box<String> stringBox = new Box<>();    // <> is the "diamond" — Java infers String
        stringBox.set("Hello Generics!");
        String text = stringBox.get();          // no (String) cast required
        System.out.println("String box: " + text);

        // A Box<Integer> can ONLY hold Integers.
        Box<Integer> numberBox = new Box<>();
        numberBox.set(42);
        int n = numberBox.get();                // unboxes straight to int
        System.out.println("Number box: " + n);

        // Pair<K, V> bundles two values of (possibly) different types.
        Pair<String, Integer> alice = new Pair<>("Alice", 95);
        Pair<String, Integer> bob = new Pair<>("Bob", 87);
        System.out.println("Pair 1: " + alice);
        System.out.println("Pair 2: " + bob);

        // Generics make collections type-safe too.
        Pair<String, Integer>[] scores = new Pair[]{ alice, bob };
        System.out.println("All pairs: " + Arrays.toString(scores));
    }
}

String box: Hello Generics!
Number box: 42
Pair 1: (Alice -> 95)
Pair 2: (Bob -> 87)
All pairs: [(Alice -> 95), (Bob -> 87)]

import java.util.List;

public class Main {
    // Generic METHOD — the <T> before the return type declares the parameter.
    // Works with an array of ANY type.
    static <T> void printArray(T[] array, String label) {
        StringBuilder sb = new StringBuilder(label + ": [");
        for (int i = 0; i < array.length; i++) {
            sb.append(array[i]);
            if (i < array.length - 1) sb.append(", ");
        }
        System.out.println(sb.append("]"));
    }

    // <T> T pick — returns whichever argument is non-null.
    static <T> T pick(T a, T b) {
        return a != null ? a : b;
    }

    // BOUNDED: T must be Comparable, so the compiler lets us call compareTo.
    static <T extends Comparable<T>> T findMax(T[] array) {
        T max = array[0];
        for (T item : array) if (item.compareTo(max) > 0) max = item;
        return max;
    }

    // PECS — Producer Extends: we only READ Numbers out of the list.
    static double sum(List<? extends Number> numbers) {
        double total = 0;
        for (Number x : numbers) total += x.doubleValue();
        return total;
    }

    public static void main(String[] args) {
        printArray(new Integer[]{1, 2, 3, 4, 5}, "Integers");
        printArray(new String[]{"Alice", "Bob", "Charlie"}, "Strings");

        System.out.println("pick(null, 7) = " + pick(null, 7));
        System.out.println("max of [5,2,8,1,9] = " + findMax(new Integer[]{5, 2, 8, 1, 9}));
        System.out.println("max of [c,a,z,b]   = " + findMax(new String[]{"c", "a", "z", "b"}));

        System.out.println("sum([1, 2, 3])       = " + sum(List.of(1, 2, 3)));
        System.out.println("sum([1.5, 2.5, 3.5]) = " + sum(List.of(1.5, 2.5, 3.5)));
    }
}

Integers: [1, 2, 3, 4, 5]
Strings: [Alice, Bob, Charlie]
pick(null, 7) = 7
max of [5,2,8,1,9] = 9
max of [c,a,z,b]   = z
sum([1, 2, 3])       = 6.0
sum([1.5, 2.5, 3.5]) = 7.5

public class Main {
    // 🎯 YOUR TURN — fill in the blanks marked with ___

    // A simple generic container that remembers ONE value of any type.
    static class Holder<___> {        // 👉 declare a type parameter named T
        private T value;
        void set(T v) { value = v; }
        ___ get() { return value; }   // 👉 this method returns a T
    }

    public static void main(String[] args) {
        Holder<String> name = new Holder<>();
        name.set("Ada");
        Holder<Integer> year = new Holder<>();
        year.set(1815);

        System.out.println("Name: " + name.get());
        System.out.println("Year: " + year.get());

        // ✅ Expected output:
        // Name: Ada
        // Year: 1815
    }
}

public class Main {
    // 🎯 YOUR TURN — fill in the blanks marked with ___

    // A generic method that returns the SMALLER of two values.
    // It needs a Comparable bound so it can call compareTo.
    static <T extends ___<T>> T min(T a, T b) {   // 👉 the bound interface (think "compare")
        return a.compareTo(b) ___ 0 ? a : b;       // 👉 operator: negative means a is smaller
    }

    public static void main(String[] args) {
        System.out.println("min(3, 9)        = " + min(3, 9));
        System.out.println("min(apple, kiwi) = " + min("apple", "kiwi"));

        // ✅ Expected output:
        // min(3, 9)        = 3
        // min(apple, kiwi) = apple
    }
}

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

public class Main {
    // A type-safe generic stack — works for any element type T.
    static class Stack<T> {
        private final List<T> items = new ArrayList<>();
        void push(T item) { items.add(item); }
        T pop() {
            if (isEmpty()) throw new RuntimeException("Stack underflow!");
            return items.remove(items.size() - 1);   // returns a T, no cast
        }
        T peek() {
            if (isEmpty()) throw new RuntimeException("Stack is empty!");
            return items.get(items.size() - 1);
        }
        boolean isEmpty() { return items.isEmpty(); }
        @Override public String toString() { return items.toString(); }
    }

    // Reuses Stack<Character> to validate balanced brackets.
    static boolean checkBrackets(String str) {
        Stack<Character> stack = new Stack<>();
        for (char ch : str.toCharArray()) {
            if (ch == '(' || ch == '[' || ch == '{') stack.push(ch);
            else if (ch == ')' || ch == ']' || ch == '}') {
                if (stack.isEmpty()) return false;
                char open = stack.pop();
                if ((ch == ')' && open != '(') ||
                    (ch == ']' && open != '[') ||
                    (ch == '}' && open != '{')) return false;
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        // Same Stack class, a String element type.
        Stack<String> undo = new Stack<>();
        undo.push("Type Hello");
        undo.push("Bold text");
        undo.push("Add image");
        System.out.println("Stack: " + undo);
        System.out.println("Undo:  " + undo.pop());
        System.out.println("Top:   " + undo.peek());

        String[] tests = { "(a + b) * [c]", "((a + b)", "{[()]}", "([)]" };
        for (String t : tests) {
            System.out.println("'" + t + "' -> " + (checkBrackets(t) ? "valid" : "invalid"));
        }

        // The compiler stops you mixing types: undo.push(42) would NOT compile.
        try {
            new Stack<Integer>().pop();
        } catch (RuntimeException e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }
}

Stack: [Type Hello, Bold text, Add image]
Undo:  Add image
Top:   Bold text
'(a + b) * [c]' -> valid
'((a + b)' -> invalid
'{[()]}' -> valid
'([)]' -> invalid
Caught: Stack underflow!

public class Main {
    // 🎯 MINI-CHALLENGE: a type-safe Pair printer
    // 1. Write a generic method:  static <K, V> void printPair(K key, V value)
    //    that prints:  key => value
    // 2. Call it with ("score", 95) and ("active", true)
    //
    // ✅ Expected output:
    // score => 95
    // active => true

    public static void main(String[] args) {
        // your code here
    }
}