List vs Set vs Map — When to Use Each Collection Type

Direct Answer

List, Set, and Map are the three core collection interfaces in Java, and the choice between them encodes intent: List (ArrayList, LinkedList) is an ordered, indexed sequence allowing duplicates — use when position matters or duplicates are valid (e.g., a queue of orders, a sequence of events). Set (HashSet, LinkedHashSet, TreeSet) is a collection of unique elements — use when uniqueness is a correctness requirement (e.g., a set of user IDs, tags). Map (HashMap, LinkedHashMap, TreeMap) is a collection of key-value pairs with unique keys — use when you need fast lookup by key (e.g., user-by-ID, config-by-key). Picking the wrong interface masks bugs: using List instead of Set allows silent duplicates; using Map instead of Set wastes memory on null values. Common variants: ordered (LinkedHashSet, LinkedHashMap) for insertion-order iteration; sorted (TreeSet, TreeMap) for natural-order iteration and range queries; concurrent (CopyOnWriteArrayList, ConcurrentHashMap) for thread-safe access. For interviews: pick the interface based on intent first, then choose the implementation based on performance characteristics. Don't default to ArrayList for everything.

Deep Dive & Architecture

compute, merge, computeIfAbsent, and computeIfPresent are Map methods (Java 8+) that atomically combine get + check + put into a single operation, replacing the verbose get-check-put anti-pattern. computeIfAbsent(key, mappingFunction) — if key absent, compute value and put; most-used for lazy initialization of multi-valued maps: map.computeIfAbsent(key, k -> new ArrayList<>()).add(value). computeIfPresent(key, remappingFunction) — if key present, recompute value (or remove if null returned). compute(key, remappingFunction) — recompute regardless of presence (function gets old value or null). merge(key, value, remappingFunction) — if absent, put value; if present, apply function to combine: map.merge(word, 1, Integer::sum) is the idiomatic word-counter. Why they matter: (1) atomic in ConcurrentHashMap — no lost updates from concurrent get-check-put races; (2) less code than if (map.containsKey(k)) map.put(k, ...) else map.put(k, ...); (3) cleaner intent — the operation says what it does. Pitfalls: (1) not atomic in non-concurrent maps (HashMap) — only the API is single-call, not thread-safe; (2) returning null from a remapping function removes the key — surprising; (3) don't recursively modify the map inside the function — undefined behavior; (4) merge doesn't handle null values the same way as compute — read the Javadoc. For interviews: lead with 'replaces get-check-put, atomic in ConcurrentHashMap, idiomatic for multimap lazy-init and counters'.

List, Set, and Map are the three core collection interfaces in Java, and the choice between them encodes intent: List (ArrayList, LinkedList) is an ordered, indexed sequence allowing duplicates — use when position matters or duplicates are valid (e.g., a queue of orders, a sequence of events). Set (HashSet, LinkedHashSet, TreeSet) is a collection of unique elements — use when uniqueness is a correctness requirement (e.g., a set of user IDs, tags). Map (HashMap, LinkedHashMap, TreeMap) is a collection of key-value pairs with unique keys — use when you need fast lookup by key (e.g., user-by-ID, config-by-key). Picking the wrong interface masks bugs: using List instead of Set allows silent duplicates; using Map instead of Set wastes memory on null values. Common variants: ordered (LinkedHashSet, LinkedHashMap) for insertion-order iteration; sorted (TreeSet, TreeMap) for natural-order iteration and range queries; concurrent (CopyOnWriteArrayList, ConcurrentHashMap) for thread-safe access. For interviews: pick the interface based on intent first, then choose the implementation based on performance characteristics.

A common mistake is confusing the interface with the implementation (e.g., saying List when you mean ArrayList), or not knowing that Map does not extend Collection.

Common Mistakes & Pitfalls

Using List when Set is more appropriate (allowing silent duplicates), or using Map when a Set would suffice