The Collections Framework is Java's unified set of interfaces and classes for storing and manipulating groups of objects — List, Set, Map, Queue, and their implementations. It provides ready-made, well-tested data structures so you rarely build your own.
Collection
├── List — ordered, allows duplicates, indexed access
├── Set — no duplicates, models uniqueness
└── Queue — FIFO/priority ordering for processing
Map (separate hierarchy) — key→value pairs
List<String> list = new ArrayList<>(); // backed by an array — fast random access
list.add("a");
list.get(0); // index access — O(1)
list.contains("a"); // O(n) search
// LinkedList — fast insert/remove at ends, O(n) random access
ArrayList (array-backed, fast indexing) is the default; LinkedList suits frequent end insertions.
Set<String> set = new HashSet<>(); // O(1) add/contains, NO order
set.add("a");
set.add("a"); // ignored — duplicates not allowed
set.contains("a"); // O(1) — great for membership tests
// TreeSet — sorted order; LinkedHashSet — insertion order
HashSet gives O(1) uniqueness checks; TreeSet keeps elements sorted.
Map<String, Integer> map = new HashMap<>(); // O(1) get/put, no order
map.put("age", 30);
map.get("age"); // 30
map.getOrDefault("x", 0); // safe access with default
map.computeIfAbsent("list", k -> new ArrayList<>()); // handy for grouping
// TreeMap — sorted by key; LinkedHashMap — insertion order
HashMap is the workhorse for O(1) key-based lookup.
Need ordered + indexed + duplicates → ArrayList
Need uniqueness, fast lookup → HashSet
Need key→value, fast lookup → HashMap
Need sorted order → TreeSet / TreeMap
Need FIFO processing → ArrayDeque / LinkedList (Queue)
Need thread-safety → ConcurrentHashMap, etc.
ArrayList: get O(1), add-end O(1), contains/remove O(n)
HashMap/HashSet: get/put/contains O(1) average
TreeMap/TreeSet: O(log n) (sorted)
LinkedList: add/remove-ends O(1), get O(n)
The Collections Framework is among the most-used parts of Java — nearly every program stores and processes groups of data with it.
Choosing the right collection is a key skill that directly affects correctness and performance: ArrayList for ordered indexed data, HashSet for uniqueness, HashMap for fast key lookups, and the sorted/concurrent variants when needed.
Understanding the interfaces (List/Set/Map/Queue), their implementations, and especially the performance characteristics (O(1) HashMap lookup vs O(n) list search) lets you pick the appropriate structure rather than defaulting to the wrong one (a common cause of slow code).
It's foundational, practical knowledge for everyday Java development.