The Collections Framework provides reusable data structures and algorithms. List preserves order and allows duplicates. Set models uniqueness. Map associates keys with values.

List<String> names = new ArrayList<>();
names.add("A");
names.add("B");

Set<String> unique = new HashSet<>(names);

Map<String, Integer> counts = new HashMap<>();
counts.merge("java", 1, Integer::sum);

ArrayList is usually the default list. HashSet and HashMap provide average constant-time lookup under good hashing behavior. LinkedHashMap preserves insertion order, while TreeMap keeps keys sorted.

Queues represent ordered work. ArrayDeque is a strong general-purpose implementation for stack and queue operations. PriorityQueue orders elements according to priority.

Deque<String> stack = new ArrayDeque<>();
stack.push("first");
stack.push("second");
System.out.println(stack.pop());

Queue<String> queue = new ArrayDeque<>();
queue.offer("job-1");
queue.offer("job-2");
System.out.println(queue.poll());

PriorityQueue<Integer> priorities = new PriorityQueue<>();
priorities.offer(50);
priorities.offer(10);
System.out.println(priorities.poll());

A priority queue's internal array is not globally sorted; it maintains a heap property sufficient to retrieve the highest- or lowest-priority element efficiently.

Generics provide compile-time type safety without repeated casts.

List<String> names = new ArrayList<>();
names.add("Java");

static double sum(List<? extends Number> values) {
    double total = 0;
    for (Number value : values) {
        total += value.doubleValue();
    }
    return total;
}

? extends T is useful when a structure is primarily a producer of T. ? super T is useful when it consumes T. This is commonly remembered as PECS: Producer Extends, Consumer Super.

Generic type information is largely erased at runtime.

Java separates natural ordering from custom ordering. Comparable<T> defines a type's natural order; Comparator<T> supplies an external ordering strategy.

record Person(String name, int age) {}

List<Person> people = new ArrayList<>();
people.sort(
    Comparator.comparingInt(Person::age)
              .thenComparing(Person::name)
);

Iterators allow controlled traversal and, where supported, removal. The enhanced for loop uses an iterator for iterable collections.

Comparators should obey their contract; inconsistent ordering can cause unpredictable sorting behavior.