List<String> names = new ArrayList<>();
names.add("Ann");
names.add("Bob");
names.add(1, "Cat");          // insert at index, shifts elements right
names.get(0);                 // O(1)
names.remove("Bob");          // remove by object, O(n)
names.remove(0);              // remove by index, O(n)
names.contains("Ann");        // O(n)
names.indexOf("Ann");

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                    // removes the element at INDEX 1 (20)
nums.remove(Integer.valueOf(10));  // removes the VALUE 10

Set<String> set = new HashSet<>();
set.add("a");
set.add("a");                     // returns false, duplicate ignored
System.out.println(set.size());   // 1

Set<Integer> sorted = new TreeSet<>(List.of(5, 1, 3));
System.out.println(sorted);       // [1, 3, 5]

TreeSet<Integer> ts = new TreeSet<>(List.of(10, 20, 30, 40));
ts.first();          // 10
ts.floor(25);        // 20 (greatest element <= 25)
ts.ceiling(25);      // 30 (smallest element >= 25)
ts.headSet(30);      // [10, 20]

Set<Integer> a = new HashSet<>(Set.of(1, 2, 3));
Set<Integer> b = Set.of(2, 3, 4);

a.retainAll(b);   // intersection: [2, 3]
a.addAll(b);      // union
a.removeAll(b);   // difference

Queue<String> queue = new ArrayDeque<>();
queue.offer("a");
queue.offer("b");
queue.poll();       // "a"
queue.peek();       // "b"

// Deque as a stack (LIFO), preferred over the legacy Stack class
Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);
stack.push(2);
stack.pop();        // 2

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());

minHeap.addAll(List.of(5, 1, 3));
minHeap.poll();   // 1

// Top-K style problems
PriorityQueue<Task> tasks = new PriorityQueue<>(Comparator.comparingInt(Task::getPriority));

Map<String, Integer> stock = new HashMap<>();
stock.put("apple", 5);
stock.get("apple");                       // 5
stock.get("pear");                        // null
stock.getOrDefault("pear", 0);            // 0
stock.containsKey("apple");
stock.remove("apple");

// Modern helpers, prefer these over manual get/put
stock.putIfAbsent("kiwi", 1);
stock.computeIfAbsent("mango", k -> 10);          // compute only when key is missing
stock.merge("kiwi", 1, Integer::sum);             // increment or insert
stock.compute("kiwi", (k, v) -> v == null ? 1 : v + 1);

for (Map.Entry<String, Integer> e : stock.entrySet()) {     // best: one pass, key and value together
    System.out.println(e.getKey() + " = " + e.getValue());
}

stock.forEach((k, v) -> System.out.println(k + " = " + v));

for (String key : stock.keySet()) { /* ... */ }
for (int value : stock.values()) { /* ... */ }

String text = "to be or not to be";
Map<String, Integer> freq = new HashMap<>();
for (String word : text.split(" ")) {
    freq.merge(word, 1, Integer::sum);
}
System.out.println(freq);   // {not=1, or=1, be=2, to=2}  (HashMap order is unspecified)

class LruCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    LruCache(int capacity) {
        super(16, 0.75f, true);          // true = access order
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
}

LruCache<String, Integer> cache = new LruCache<>(2);
cache.put("a", 1);
cache.put("b", 2);
cache.get("a");          // "a" becomes most recently used
cache.put("c", 3);       // evicts "b"
System.out.println(cache.keySet());   // [a, c]

TreeMap<Integer, String> grades = new TreeMap<>();
grades.put(90, "A");
grades.put(80, "B");
grades.put(70, "C");

grades.floorEntry(85);      // 80=B  (greatest key <= 85)
grades.ceilingEntry(85);    // 90=A
grades.firstKey();          // 70
grades.headMap(90);         // {70=C, 80=B}

Map<Point, String> map = new HashMap<>();
Point key = new Point(1, 2);
map.put(key, "A");

key.setX(99);              // mutated a key used in hashCode!
map.get(key);              // null: hash changed, we now look in the wrong bucket

public class Employee implements Comparable<Employee> {
    private final String name;
    private final int salary;

    Employee(String name, int salary) { this.name = name; this.salary = salary; }
    String getName() { return name; }
    int getSalary() { return salary; }

    @Override
    public int compareTo(Employee other) {
        return Integer.compare(this.salary, other.salary);   // natural order: salary ascending
    }
}

List<Employee> staff = new ArrayList<>(/* ... */);
Collections.sort(staff);        // uses compareTo

staff.sort(Comparator.comparing(Employee::getName));                       // by name
staff.sort(Comparator.comparingInt(Employee::getSalary).reversed());       // salary descending
staff.sort(Comparator
        .comparing(Employee::getSalary, Comparator.reverseOrder())
        .thenComparing(Employee::getName));                                // salary desc, then name asc
staff.sort(Comparator.comparing(Employee::getName, Comparator.nullsLast(Comparator.naturalOrder())));

List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4));

for (Integer n : nums) {
    if (n % 2 == 0) nums.remove(n);          // ConcurrentModificationException
}

// Fix 1: iterator.remove()
Iterator<Integer> it = nums.iterator();
while (it.hasNext()) {
    if (it.next() % 2 == 0) it.remove();
}

// Fix 2 (best): removeIf
nums.removeIf(n -> n % 2 == 0);

// Fix 3: iterate a copy, or collect to a new list with streams

List<String> a = List.of("x", "y");                  // Java 9+: truly immutable, no nulls allowed
Set<Integer> s = Set.of(1, 2, 3);
Map<String, Integer> m = Map.of("a", 1, "b", 2);
Map<String, Integer> big = Map.ofEntries(Map.entry("a", 1), Map.entry("b", 2));

List<String> copy = List.copyOf(source);             // immutable snapshot copy

List<String> view = Collections.unmodifiableList(source);   // read-only VIEW of source
source.add("new");                                          // the view now shows "new" too!

List<String> fixed = Arrays.asList("a", "b");        // fixed size, set allowed, add/remove throws

// Before generics: unsafe
List raw = new ArrayList();
raw.add("text");
Integer i = (Integer) raw.get(0);      // ClassCastException at runtime

// With generics: caught at compile time
List<String> safe = new ArrayList<>();
safe.add("text");
// safe.add(42);                       // compile error

public class Box<T> {
    private T value;
    public Box(T value) { this.value = value; }
    public T get() { return value; }
}

Box<String> box = new Box<>("hi");

// Generic method: the type parameter is declared before the return type
public static <T> T firstOrDefault(List<T> list, T fallback) {
    return list.isEmpty() ? fallback : list.get(0);
}

// Bounded type: T must be Comparable to itself
public static <T extends Comparable<T>> T max(T a, T b) {
    return a.compareTo(b) >= 0 ? a : b;
}

max(3, 7);           // 7
max("pear", "apple"); // pear

// src PRODUCES values we read, dest CONSUMES values we write
public static <T> void copy(List<? extends T> src, List<? super T> dest) {
    for (T item : src) {
        dest.add(item);
    }
}

double sum(List<? extends Number> numbers) {     // works for List<Integer>, List<Double>, ...
    double total = 0;
    for (Number n : numbers) total += n.doubleValue();
    return total;
}

List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
System.out.println(a.getClass() == b.getClass());   // true

// Anonymous class
Comparator<String> c1 = new Comparator<>() {
    @Override public int compare(String a, String b) { return a.length() - b.length(); }
};

// Lambda
Comparator<String> c2 = (a, b) -> Integer.compare(a.length(), b.length());

Runnable r = () -> System.out.println("hi");

Function<Integer, Integer> doubler = x -> x * 2;
Function<Integer, Integer> plusOne = x -> x + 1;
doubler.andThen(plusOne).apply(5);    // (5 * 2) + 1 = 11
doubler.compose(plusOne).apply(5);    // (5 + 1) * 2 = 12

Predicate<String> notEmpty = s -> !s.isEmpty();
Predicate<String> shortStr = s -> s.length() < 5;
notEmpty.and(shortStr).test("java");   // true
notEmpty.negate().test("");            // true

int base = 10;
Function<Integer, Integer> add = x -> x + base;   // OK
// base++;                                        // would make the lambda above a compile error

List<String> result = people.stream()          // source
        .filter(p -> p.getAge() >= 18)         // intermediate (lazy)
        .map(Person::getName)                  // intermediate (lazy)
        .sorted()                              // intermediate
        .collect(Collectors.toList());         // terminal: triggers execution

List.of(1, 2, 3).stream();
Arrays.stream(new int[]{1, 2, 3});                // IntStream
Stream.of("a", "b", "c");
IntStream.range(0, 5);                            // 0..4
IntStream.rangeClosed(1, 5);                      // 1..5
Stream.iterate(1, x -> x * 2).limit(5);           // 1, 2, 4, 8, 16
Stream.generate(Math::random).limit(3);
"hello".chars();                                  // IntStream of char codes

List<Integer> nums = List.of(1, 2, 3, 4, 5, 6);

nums.stream().filter(n -> n % 2 == 0).toList();              // [2, 4, 6]
nums.stream().map(n -> n * n).toList();                      // [1, 4, 9, 16, 25, 36]
nums.stream().skip(2).limit(3).toList();                     // [3, 4, 5]
List.of(3, 1, 3, 2).stream().distinct().sorted().toList();   // [1, 2, 3]

// flatMap: flatten nested collections into one stream
List<List<Integer>> nested = List.of(List.of(1, 2), List.of(3), List.of(4, 5));
nested.stream().flatMap(List::stream).toList();              // [1, 2, 3, 4, 5]

nums.stream().count();                                        // 6
nums.stream().anyMatch(n -> n > 5);                           // true
nums.stream().allMatch(n -> n > 0);                           // true
nums.stream().noneMatch(n -> n > 10);                         // true
nums.stream().findFirst();                                    // Optional[1]
nums.stream().max(Integer::compare);                          // Optional[6]
nums.stream().reduce(0, Integer::sum);                        // 21
nums.stream().mapToInt(Integer::intValue).sum();              // 21  (primitive stream, no boxing)
nums.stream().mapToInt(Integer::intValue).average();          // OptionalDouble[3.5]
nums.stream().mapToInt(Integer::intValue).summaryStatistics(); // count, sum, min, avg, max
nums.forEach(System.out::println);

record Employee(String name, String dept, int salary) {}

List<Employee> emps = List.of(
    new Employee("Ann", "ENG", 120),
    new Employee("Bob", "ENG", 100),
    new Employee("Cat", "HR", 80)
);

// To collections
emps.stream().map(Employee::name).collect(Collectors.toList());
emps.stream().map(Employee::dept).collect(Collectors.toSet());
emps.stream().collect(Collectors.toMap(Employee::name, Employee::salary));
// toMap throws IllegalStateException on duplicate keys unless you pass a merge function:
emps.stream().collect(Collectors.toMap(Employee::dept, Employee::salary, Integer::sum));

// Joining strings
emps.stream().map(Employee::name).collect(Collectors.joining(", ", "[", "]"));   // [Ann, Bob, Cat]

// Grouping
Map<String, List<Employee>> byDept =
    emps.stream().collect(Collectors.groupingBy(Employee::dept));

Map<String, Long> countByDept =
    emps.stream().collect(Collectors.groupingBy(Employee::dept, Collectors.counting()));
// {HR=1, ENG=2}  (groupingBy returns a HashMap, so key order is unspecified)

Map<String, Integer> totalByDept =
    emps.stream().collect(Collectors.groupingBy(Employee::dept, Collectors.summingInt(Employee::salary)));
// {HR=80, ENG=220}

Map<String, Double> avgByDept =
    emps.stream().collect(Collectors.groupingBy(Employee::dept, Collectors.averagingInt(Employee::salary)));

// Map each group to a different value
Map<String, List<String>> namesByDept = emps.stream().collect(
    Collectors.groupingBy(Employee::dept, Collectors.mapping(Employee::name, Collectors.toList())));

// Partition into exactly two groups: true and false
Map<Boolean, List<Employee>> highLow =
    emps.stream().collect(Collectors.partitioningBy(e -> e.salary() >= 100));

List<String> top2 = emps.stream()
        .sorted(Comparator.comparingInt(Employee::salary).reversed())
        .limit(2)
        .map(Employee::name)
        .toList();
// [Ann, Bob]

// BUG: mutating a shared, non-thread-safe list from a parallel stream
List<Integer> out = new ArrayList<>();
IntStream.range(0, 1000).parallel().forEach(out::add);   // lost updates or exceptions

// Fix: let the stream collect
List<Integer> ok = IntStream.range(0, 1000).parallel().boxed().toList();

Optional<User> findUser(String id) { /* ... */ }

Optional<User> maybe = findUser("42");

maybe.isPresent();                                  // true or false
maybe.orElse(defaultUser);                          // value or fallback (fallback ALWAYS evaluated)
maybe.orElseGet(() -> createDefaultUser());         // fallback computed lazily
maybe.orElseThrow(() -> new NotFoundException("42"));
maybe.ifPresent(u -> System.out.println(u.getName()));
maybe.ifPresentOrElse(u -> log(u), () -> log("missing"));   // Java 9+

// Transform without null checks
String city = findUser("42")
        .map(User::getAddress)
        .map(Address::getCity)
        .orElse("Unknown");

Optional.of(value);          // throws NullPointerException if value is null
Optional.ofNullable(value);  // empty if null
Optional.empty();