Generics
&
Streams
& Patterns

// BEFORE Generics (Java 1.4)
List list = new ArrayList();
list.add("hello");
Integer n = (Integer) list.get(0);  // ClassCastException at runtime

// AFTER Generics (Java 5+)
List<String> list = new ArrayList<>();
list.add("hello");
Integer n = (Integer) list.get(0);  // COMPILE ERROR — type safety

// Source code
List<String> strings = new ArrayList<String>();
strings.add("hi");
String s = strings.get(0);

// After type erasure (what JVM sees)
List strings = new ArrayList();
strings.add("hi");
String s = (String) strings.get(0);  // compiler inserts cast

// PECS example
public static void process(List<? extends Number> producer) { // PRODUCER — read only
    for (Number n : producer) System.out.println(n);
}

public static void fill(List<? super Integer> consumer) { // CONSUMER — write only
    consumer.add(10);
    consumer.add(20);
}

List<String>[] stringLists = new ArrayList<String>[10];  // COMPILE ERROR

// Workaround: raw type ya wildcard use karo
List[] stringLists = new ArrayList[10];          // OK but unchecked warning
List<?>[] stringLists = new ArrayList<?>[10];    // OK

Throwable
  ├── Error           (unchecked, JVM level — OutOfMemoryError, StackOverflowError)
  └── Exception
        ├── IOException           (checked — file, network failures)
        ├── SQLException          (checked)
        ├── ClassNotFoundException (checked)
        └── RuntimeException     (unchecked)
              ├── NullPointerException
              ├── ArrayIndexOutOfBoundsException
              ├── ArithmeticException
              └── IllegalArgumentException

// Old way
FileReader fr = null;
try {
    fr = new FileReader("file.txt");
    // read file
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fr != null) try { fr.close(); } catch (IOException e) {}
}

// NEW way (Java 7+) — cleaner
try (FileReader fr = new FileReader("file.txt")) {
    // read file — fr auto-closed
} catch (IOException e) {
    e.printStackTrace();
}

public void withdraw(double amount) throws InsufficientFundsException {  // DECLARE
    if (amount > balance)
        throw new InsufficientFundsException("Not enough money");  // ACTUALLY THROW
    balance -= amount;
}

// Checked — caller ko handle karna chahiye
public class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String msg) { super(msg); }
}

// Unchecked — programming error
public class InvalidAgeException extends RuntimeException {
    public InvalidAgeException(String msg) { super(msg); }
}

// Multi-catch (Java 7+)
try {
    Class.<String>forName("com.foo.Bar").newInstance();
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
    logger.error("Failed to load class", e);
}

// Multi-resource try-with-resources
try (FileReader fr = new FileReader("in.txt");
     FileWriter fw = new FileWriter("out.txt")) {
    fw.write(fr.readAllBytes());
}  // both auto-closed in REVERSE order

List<String> names = Arrays.asList("Alice", "Bob", "Anna", "Charlie");

List<String> result = names.stream()              // 1. Source
    .filter(n -> n.startsWith("A"))           // 2a. Intermediate (lazy)
    .map(String::toUpperCase)                  // 2b. Intermediate (lazy)
    .sorted()                                     // 2c. Intermediate (lazy)
    .collect(Collectors.toList());          // 3. Terminal (triggers execution)
// Result: [ALICE, ANNA]

List<List<Integer>> nested = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4, 5),
    Arrays.asList(6)
);

// map() — flat nahi karta
List<Stream<Integer>> mapped = nested.stream().map(l -> l.stream()).collect(Collectors.toList());

// flatMap() — flatten karta hai
List<Integer> flat = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());
// Result: [1, 2, 3, 4, 5, 6]

// Anonymous class — old, verbose
Runnable r1 = new Runnable() {
    public void run() { System.out.println("old"); }
};

// Lambda — new, concise
Runnable r2 = () -> System.out.println("new");

// With parameters
Comparator<Integer> cmp = (a, b) -> a.compareTo(b);

// Multi-line body
Function<Integer, Integer> square = x -> {
    return x * x;
};

// Old way — null check required
String name = user.getName();
if (name != null) System.out.println(name.toUpperCase());

// New way — Optional
Optional<String> opt = user.getNameOptional();
String result = opt
    .map(String::toUpperCase)
    .orElse("DEFAULT");   // safe default

// Common methods
opt.isPresent()        // true if has value
opt.ifPresent(System.out::println)  // run lambda only if present
opt.orElseThrow(() -> new NotFoundException("missing"))  // throw if empty

// 1. Eager initialization (simple but wastes memory)
public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() { return INSTANCE; }
}

// 2. Bill Pugh Singleton (BEST — lazy + thread-safe, no synchronization)
public class BillPughSingleton {
    private BillPughSingleton() {}
    private static class Helper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }
    public static BillPughSingleton getInstance() { return Helper.INSTANCE; }
}

// 3. Enum Singleton (best against reflection + serialization)
public enum EnumSingleton {
    INSTANCE;
    public void doWork() { /* ... */ }
}

interface Shape { void draw(); }
class Circle implements Shape { public void draw() { System.out.println("○"); } }
class Square implements Shape { public void draw() { System.out.println("□"); } }

public class ShapeFactory {
    public static Shape create(String type) {
        return switch (type) {
            case "circle" -> new Circle();
            case "square" -> new Square();
            default -> throw new IllegalArgumentException("Unknown: " + type);
        };
    }
}

// Client code
Shape s = ShapeFactory.create("circle");  // no new keyword!
s.draw();

public class User {
    private final String name;        // required
    private final String email;       // required
    private final int age;            // optional
    private final String phone;       // optional
    private final String address;     // optional

    private User(Builder b) {
        this.name = b.name;
        this.email = b.email;
        this.age = b.age;
        this.phone = b.phone;
        this.address = b.address;
    }

    public static class Builder {
        private final String name, email;
        private int age;
        private String phone, address;
        public Builder(String name, String email) { this.name = name; this.email = email; }
        public Builder age(int v) { this.age = v; return this; }
        public Builder phone(String v) { this.phone = v; return this; }
        public Builder address(String v) { this.address = v; return this; }
        public User build() { return new User(this); }
    }
}

// Usage
User u = new User.Builder("Pritam", "p@x.com").age(25).phone("999").build();

interface Observer { void update(String msg); }
class Subject {
    private final List<Observer> observers = new ArrayList<>();
    public void subscribe(Observer o) { observers.add(o); }
    public void notifyAll(String msg) {
        observers.forEach(o -> o.update(msg));
    }
}

// Real-world: YouTube channel
Subject channel = new Subject();
channel.subscribe(msg -> System.out.println("Email: " + msg));
channel.subscribe(msg -> System.out.println("Push: " + msg));
channel.notifyAll("New video uploaded!");  // both notified

interface PaymentStrategy { void pay(int amount); }
class CreditCard implements PaymentStrategy {
    public void pay(int amount) { System.out.println("Paid " + amount + " via CC"); }
}
class UPI implements PaymentStrategy {
    public void pay(int amount) { System.out.println("Paid " + amount + " via UPI"); }
}

class ShoppingCart {
    private PaymentStrategy strategy;
    public void setStrategy(PaymentStrategy s) { this.strategy = s; }
    public void checkout(int amount) { strategy.pay(amount); }
}

// Runtime pe strategy change
ShoppingCart cart = new ShoppingCart();
cart.setStrategy(new CreditCard()); cart.checkout(500);
cart.setStrategy(new UPI());        cart.checkout(500);

// 1. Extend Thread class
class MyThread extends Thread {
    public void run() { System.out.println("Thread running"); }
}
new MyThread().start();

// 2. Implement Runnable (PREFERRED — Java doesn't support multiple inheritance)
Runnable r = () -> System.out.println("Runnable running");
new Thread(r).start();

// Modern: ExecutorService (BEST for production)
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("From pool"));
pool.shutdown();

private volatile boolean running = true;  // visible to all threads

public void run() {
    while (running) { /* work */ }
}

public void stop() { running = false; }  // all threads see this

String a = new String("hi");
String b = new String("hi");
a == b        // false (different objects)
a.equals(b)  // true  (same content)

public final class ImmutablePoint {
    private final int x, y;
    public ImmutablePoint(int x, int y) { this.x = x; this.y = y; }
    public int getX() { return x; }
    public int getY() { return y; }
}