Java Collections Framework

JavaEntryjava

The Question

What are collections in Java?

What a Strong Answer Covers

• java.util package
• unified framework
• List/Set/Queue/Map interfaces
• ArrayList/HashMap/HashSet implementations
• Collections utility class
• stores and manipulates groups of objects

Senior-Level Answer

The Java Collections Framework (JCF) is a unified architecture for representing and manipulating groups of objects. It consists of interfaces that define abstract data types, concrete implementations of those interfaces, and algorithms (utility methods in `Collections` and `Arrays`) that operate on them.

The core interfaces are: - `Collection` — the root interface. Defines basic operations: `add()`, `remove()`, `contains()`, `size()`, `iterator()`. - `List` — an ordered sequence allowing duplicates. Key implementations: `ArrayList` (dynamic array, O(1) random access), `LinkedList` (doubly-linked, O(1) head/tail insert). - `Set` — a collection with no duplicates. `HashSet` (hash table, O(1) average ops), `TreeSet` (red-black tree, sorted, O(log n)), `LinkedHashSet` (insertion-ordered). - `Queue` / `Deque` — FIFO and double-ended queue. `ArrayDeque`, `LinkedList`, `PriorityQueue`. - `Map` — key-value pairs, not a `Collection` subtype. `HashMap` (O(1) average), `TreeMap` (sorted by key), `LinkedHashMap` (insertion-ordered).

The framework is built on the principle of separating interface from implementation. Writing code against `List` rather than `ArrayList` allows you to swap implementations without changing calling code.

Key utility classes: `Collections` provides static methods for sorting, shuffling, reversing, finding min/max, and wrapping collections in thread-safe or unmodifiable views. `Arrays` bridges arrays to the framework.

Thread safety is not provided by default in most JCF implementations. For concurrent use, prefer `java.util.concurrent` classes: `ConcurrentHashMap`, `CopyOnWriteArrayList`, `BlockingQueue` implementations. Alternatively, `Collections.synchronizedList()` wraps any list with synchronized access, though iterators still require external locking.

What Separates a 2/3 from a 3/3

Common Mistakes

• Treating Map as a subtype of Collection — Map does not extend Collection in the JCF hierarchy.
• Defaulting to Vector or Hashtable for thread safety instead of modern java.util.concurrent classes.
• Not knowing the time complexity differences between ArrayList, LinkedList, HashSet, and TreeSet.

Follow-Up Questions

• When would you choose LinkedList over ArrayList? — Frequent insertions/deletions at the head or middle; ArrayList's O(n) shift cost dominates in those scenarios.
• How does HashSet enforce uniqueness? — It uses a backing HashMap; add() calls map.put(e, PRESENT) and checks if the key already exists via equals/hashCode.
• What is the difference between Collections.unmodifiableList() and an immutable list from List.of()? — unmodifiableList is a view — mutations to the backing list are visible. List.of() is truly immutable with no backing list.

Related Questions

• JVM vs JRE vs JDK
• Java Platform Independence
• How JVM Works
• Main Features of Java
• public static void main