Java Collections

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

List<String> names = new ArrayList<>();
names.add("Alice");           // append
names.add(0, "Bob");          // insert at index
names.addAll(List.of("Carol","Dan"));

// Create with initial values (Java 9+)
List<Integer> nums = new ArrayList<>(
    List.of(1, 2, 3, 4, 5));

names.get(0)             // "Bob"
names.set(0, "Ben")       // replace index 0
names.remove(0)           // remove by index
names.remove("Alice")     // remove by value
names.size()              // count
names.isEmpty()           // boolean
names.contains("Carol")  // boolean
names.indexOf("Dan")      // index or -1
names.clear()             // remove all
names.subList(1, 3)       // view [1..2]

// For-each (most common)
for (String n : names) System.out.println(n);

// Index loop
for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

// Sort (natural / custom)
Collections.sort(names);
names.sort(Comparator.reverseOrder());

import java.util.LinkedList;
import java.util.Deque;

Deque<String> dq = new LinkedList<>();

// Add to either end
dq.addFirst("front");
dq.addLast("back");

// Peek without removing
dq.peekFirst();
dq.peekLast();

// Remove from either end
dq.pollFirst();
dq.pollLast();

// Use Deque as a stack
Deque<Integer> stack = new LinkedList<>();
stack.push(1);  // addFirst
stack.push(2);
stack.peek();  // 2 — top, no remove
stack.pop();   // 2 — removes top

// Avoid java.util.Stack (legacy)
// Prefer ArrayDeque for stack needs
Deque<Integer> s = new ArrayDeque<>();

import java.util.HashSet;
import java.util.Set;

Set<String> tags = new HashSet<>();
tags.add("java");
tags.add("java");      // ignored — duplicate
tags.contains("java")  // true — O(1)
tags.remove("java")   // removes
tags.size()           // count

// Iterate (order not guaranteed)
for (String t : tags)
    System.out.println(t);

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

// Union: a ∪ b
Set<Integer> union = new HashSet<>(a);
union.addAll(b);         // {1,2,3,4}

// Intersection: a ∩ b
Set<Integer> inter = new HashSet<>(a);
inter.retainAll(b);      // {2,3}

// Difference: a − b
Set<Integer> diff = new HashSet<>(a);
diff.removeAll(b);       // {1}

import java.util.Queue;
import java.util.LinkedList;

Queue<String> q = new LinkedList<>();
q.offer("first");  // enqueue — safe
q.offer("second");
q.peek();          // "first" — no remove
q.poll();          // "first" — removes
q.isEmpty();       // false
q.size();          // 1

// prefer offer/poll/peek over
// add/remove/element (no exception)

import java.util.PriorityQueue;

PriorityQueue<Integer> pq =
    new PriorityQueue<>();
pq.offer(5); pq.offer(1); pq.offer(3);
pq.peek();   // 1 — smallest
pq.poll();   // 1 — removes smallest

// Max-heap — reverse order
PriorityQueue<Integer> maxPQ =
    new PriorityQueue<>(Comparator.reverseOrder());

import java.util.Collections;

List<Integer> list = new ArrayList<>(
    List.of(3,1,4,1,5,9));

Collections.sort(list);                  // [1,1,3,4,5,9]
Collections.reverse(list);               // [9,5,4,3,1,1]
Collections.shuffle(list);               // random order
Collections.min(list);                   // 1
Collections.max(list);                   // 9
Collections.frequency(list, 1);         // 2
Collections.fill(list, 0);              // all zeros
Collections.nCopies(3, "x");           // ["x","x","x"]
Collections.unmodifiableList(list);     // read-only view
Collections.synchronizedList(list);    // thread-safe
Collections.disjoint(list, other);     // no common elements?

// ? — any type (unbounded)
void printAll(List<?> list) {
    for (Object o : list) System.out.println(o);
}

// ? extends T — upper bound (read)
double sum(List<? extends Number> nums) {
    return nums.stream().mapToDouble(
        Number::doubleValue).sum();
}

// ? super T — lower bound (write)
void addNumbers(List<? super Integer> list) {
    list.add(1); list.add(2);
}