6.3 Collections Framework: List, Set, Queue, and Deque APIs

6.3 Collections Framework: List, Set, Queue, and Deque APIs

The Java Collections Framework (JCF) provides a unified architecture for managing groups of objects. Defined primarily in java.util, the framework separates abstract behavioral contracts (interfaces) from concrete data structure implementations. The 1Z0-829 examination tests deep familiarity with collection hierarchies, operation complexities, null handling nuances, queue/deque method dualities, and modern unmodifiable collection factories.

---

The Core Collection Hierarchy

The root interface for collections is java.lang.Iterable<T>, which enables the enhanced for loop. java.util.Collection<E> extends Iterable<E> and defines fundamental bulk and element operations inherited by List, Set, and Queue.

           Iterable<E>
               │
          Collection<E>
        ┌──────┼──────┐
        │      │      │
     List<E> Set<E> Queue<E>
        │      │      │
        │ NavigableSet Deque<E>

Core Collection methods include:

• add(E e), addAll(Collection<? extends E> c): Inserts elements.
• remove(Object o), removeAll(Collection<?> c): Removes matching elements.
• removeIf(Predicate<? super E> filter): Removes all elements matching the given predicate in place (introduced in Java 8).
• retainAll(Collection<?> c): Retains only elements contained in the specified collection (intersection).
• contains(Object o), containsAll(Collection<?> c): Membership tests.
• size(), isEmpty(), clear(), toArray(): Structural queries and conversions.

---

The List Interface and Implementations

A List<E> is an ordered collection (sequence) that allows duplicate elements and precise positional access via zero-based integer indices (get(int), set(int, E), add(int, E), remove(int)).

ArrayList vs. LinkedList

The List<Integer>.remove() Overload Trap

A primary exam pitfall involves method overloading between remove(int index) and remove(Object o) on integer lists:

List<Integer> numbers = new ArrayList<>(List.of(10, 20, 30));

// Invokes remove(int index): removes element at index 1 (value 20)
numbers.remove(1); 
System.out.println(numbers); // Prints [10, 30]

// Invokes remove(Object o): removes the value 10
numbers.remove(Integer.valueOf(10));
System.out.println(numbers); // Prints [30]

// Attempting numbers.remove(30) treats 30 as an INDEX!
// numbers.remove(30); // Throws IndexOutOfBoundsException at runtime!

---

The Set Interface and Implementations

A Set<E> represents an unordered collection that prohibits duplicate elements. If an element e is already present (where existing.equals(e) is true), calling add(e) returns false and leaves the set unmodified.

Comparison of Core Set Implementations

NavigableSet Navigation Methods

TreeSet implements NavigableSet<E> (which extends SortedSet<E>), offering rich directional search methods:

• lower(e): Greatest element strictly less than e (< e), or null.
• floor(e): Greatest element less than or equal to e (<= e), or null.
• ceiling(e): Least element greater than or equal to e (>= e), or null.
• higher(e): Least element strictly greater than e (> e), or null.
• pollFirst(), pollLast(): Retrieves and removes the lowest or highest element, or returns null if empty.
• descendingSet(): Returns a reverse-order view of the set.

NavigableSet<Integer> set = new TreeSet<>(List.of(10, 20, 30, 40));
System.out.println(set.lower(20));   // 10 (strictly < 20)
System.out.println(set.floor(20));   // 20 (<= 20)
System.out.println(set.ceiling(25)); // 30 (>= 25)
System.out.println(set.higher(30));  // 40 (strictly > 30)

---

The Queue and Deque Interfaces

Queues model collections designed for holding elements prior to processing. Queue<E> handles First-In, First-Out (FIFO) ordering, while Deque<E> (Double-Ended Queue) supports insertion and removal at both ends, serving as both a FIFO queue and a Last-In, First-Out (LIFO) stack.

Method Dualities: Exception vs. Special Value

Queue operations are structured into two distinct sets of methods based on failure handling:

Deque Operations and Stack Methods

Deque expands these dualities to both the head and tail:

• Head Operations: addFirst, offerFirst, removeFirst, pollFirst, getFirst, peekFirst.
• Tail Operations: addLast, offerLast, removeLast, pollLast, getLast, peekLast.
• Stack Methods (LIFO):
  • push(e): Equivalent to addFirst(e) (inserts at head; throws exception if capacity reached).
  • pop(): Equivalent to removeFirst() (removes from head; throws NoSuchElementException if empty).
  • peek(): Equivalent to peekFirst() (inspects head; returns null if empty).

ArrayDeque as Preferred Stack and Queue

ArrayDeque is the industry-standard implementation of Deque backed by a circular array. It is significantly faster and more cache-efficient than LinkedList or legacy java.util.Stack (which is synchronized and extends Vector).

---

Unmodifiable Collection Factories vs. Arrays.asList

Java 9 introduced static factory methods (List.of(), Set.of()) that produce unmodifiable collection instances. Understanding the operational differences between these factories, List.copyOf(), and Arrays.asList() is vital for the exam.

// 1. Arrays.asList: Fixed-size, backed by underlying array
String[] arr = { "A", "B" };
List<String> backedList = Arrays.asList(arr);
backedList.set(0, "Z"); // Allowed! Updates array: arr[0] becomes "Z"
// backedList.add("C"); // Throws UnsupportedOperationException (cannot change size)

// 2. List.of: Truly immutable instance
List<String> immutableList = List.of("A", "B");
// immutableList.set(0, "Z"); // Throws UnsupportedOperationException
// List.of("A", null);        // Throws NullPointerException (nulls forbidden!)

// 3. Set.of: Truly immutable set (rejects duplicates and nulls)
// Set.of("A", "A");          // Throws IllegalArgumentException (duplicate elements!)
// Set.of("A", null);         // Throws NullPointerException

// 4. List.copyOf: Unmodifiable defensive copy
List<String> copy = List.copyOf(backedList);
// If source contains null, List.copyOf throws NullPointerException!

Summary Comparison of Collection Creation Methods