Collections
30 interview questions and answers in the Collections section.
Questions in this section
- What are the main Collection Framework interfaces?
- What is the difference between List, Set and Queue?
- What is the difference between ArrayList and LinkedList?
- When to use ArrayList vs LinkedList?
- What is the time complexity of operations in ArrayList?
- What is the time complexity of operations in LinkedList?
- What is Vector and how does it differ from ArrayList?
- What is Stack?
- What is Queue and what implementations exist?
- What is Deque?
- What is the difference between HashSet, LinkedHashSet and TreeSet?
- How does HashSet work internally?
- What is TreeSet and how does it work?
- What is Map and what implementations exist?
- What is the difference between HashMap, LinkedHashMap and TreeMap?
- When to use TreeMap?
- What is WeakHashMap?
- What is ConcurrentHashMap?
- How does ConcurrentHashMap ensure thread-safety?
- What is CopyOnWriteArrayList?
- When to use synchronized collections?
- How to get a synchronized collection?
- What is Collections.unmodifiableList()?
- How does Collections.unmodifiableList() work internally?
- What is the difference between Iterator and ListIterator?
- What are fail-fast and fail-safe iterators?
- What is ConcurrentModificationException?
- How to properly remove elements during iteration?
- What is Comparable and Comparator?
- What operations does the Collection interface support?
Study navigator
30 questions for Middle Java Developer interview preparation.
📋 All Questions
🗺️ Topic Dependency Map
┌──────────────────────────────────────────┐
│ 1. Collection Framework (Overview) │
│ Collection, List, Set, Queue, Map │
└──┬──────────┬──────────┬─────────────────┘
│ │ │
┌──────────┘ │ └──────────┐
▼ ▼ ▼
┌───────────────┐ ┌───────────────┐ ┌────────────────────┐
│ LIST (3-10) │ │ SET (11-13) │ │ MAP (14-20) │
│ 3. ArrayList │ │ 11. HashSet │ │ 14. Map overview │
│ vs Linked │ │ vs Linked │ │ 15. HashMap vs │
│ 4. When what │ │ vs Tree │ │ LinkedHashMap │
│ 5-6. Big O │ │ 12. HashSet │ │ vs TreeMap │
│ 7. Vector │ │ internals │ │ 16. When TreeMap │
│ 8. Stack │ │ 13. TreeSet │ │ 17. WeakHashMap │
│ 9. Queue │ │ │ │ 18-19. CHM │
│ 10. Deque │ │ │ │ 20. CopyOnWrite │
└───────┬───────┘ └───────┬───────┘ └────────┬───────────┘
│ │ │
└────────────────────┼─────────────────────┘
▼
┌──────────────────────────────────────────┐
│ THREAD-SAFETY (18-22) │
│ 18-19. ConcurrentHashMap │
│ 20. CopyOnWriteArrayList │
│ 21-22. synchronized collections │
└──────────────────────────────────────────┘
┌──────────────────────────────────────────┐
│ ITERATORS and REMOVAL (23-28) │
│ 23-24. unmodifiableList │
│ 25. Iterator vs ListIterator │
│ 26. fail-fast vs fail-safe │
│ 27. ConcurrentModificationException │
│ 28. Proper removal │
└──────────────────────────────────────────┘
┌──────────────────────────────────────────┐
│ COMPARISON and COMMON OPS (29, 31) │
│ 29. Comparable vs Comparator │
│ 31. Collection operations │
└──────────────────────────────────────────┘
🎯 Recommended Study Order
🟢 Junior Level (weeks 1-2)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Collection Framework Overview | Q1, Q2 | Interface hierarchy, List vs Set vs Queue |
| 2 | List: ArrayList vs LinkedList | Q3, Q4 | When to use what |
| 3 | Vector, Stack, Queue, Deque | Q7, Q8, Q9, Q10 | Legacy and modern analogs |
| 4 | Set: HashSet vs TreeSet | Q11, Q13 | Uniqueness and sorting |
| 5 | Map: HashMap vs TreeMap | Q14, Q15, Q16 | When to use what |
| 6 | unmodifiableList | Q23, Q24 | Defensive copying |
| 7 | Iterator vs ListIterator | Q25 | Iteration and removal |
🟡 Middle Level (weeks 3-4)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | Big O ArrayList | Q5 | Amortization, resize, System.arraycopy |
| 2 | Big O LinkedList | Q6 | Cache miss, GC pressure |
| 3 | HashSet internals | Q12 | hashCode, equals, treeification |
| 4 | WeakHashMap | Q17 | WeakReference, GC, ReferenceQueue |
| 5 | synchronized collections | Q21, Q22 | Decorator, mutex, check-then-act |
| 6 | fail-fast/fail-safe | Q26 | modCount, CME, snapshot |
| 7 | CME | Q27 | Causes, subList trap, views |
| 8 | Removal during iteration | Q28 | removeIf, Iterator.remove |
| 9 | Comparable vs Comparator | Q29 | Timsort, overflow, transitivity |
| 10 | Collection operations | Q31 | bulk ops, parallelStream, Spliterator |
🔴 Senior Level (weeks 5-6)
| Step | Topic | Files | Goal |
|---|---|---|---|
| 1 | ArrayList internals | Q5 (Senior) | SIMD, branch prediction, CPU pipeline |
| 2 | LinkedList internals | Q6 (Senior) | Cache locality catastrophe, pipeline stall |
| 3 | CHM thread-safety | Q18, Q19 | CAS, volatile, synchronized, LongAdder |
| 4 | CopyOnWriteArrayList | Q20 | Fail-safe, stale data, eventual consistency |
| 5 | HashSet internals | Q12 (Senior) | Treeification, transient, hash collisions |
| 6 | TreeMap internals | Q13, Q16 | Red-black tree, rebalancing, Skip List |
| 7 | unmodifiableList internals | Q24 | Defensive copy, RandomAccess, GC pressure |
| 8 | Concurrent collections | Q21 (Senior) | High contention, compound operations |
🔗 Key Connections Between Topics
Topic: List
Q3 (ArrayList vs LinkedList) → Q4 (When to use what) → Q5-Q6 (Big O)
↓
Q7 (Vector) → Q8 (Stack) → Q9 (Queue) → Q10 (Deque)
Key connections:
- Q3 ↔ Q5-Q6: Big O explains why ArrayList is faster than LinkedList in practice
- Q4 ↔ Q28: removeIf() solves the removal-in-loop problem
- Q7 ↔ Q18: Vector → ConcurrentHashMap (evolution of thread-safety)
- Q9-Q10 ↔ Q18: BlockingQueue, ConcurrentLinkedQueue as alternatives
Topic: Set
Q11 (HashSet vs LinkedHashSet vs TreeSet) → Q12 (HashSet internals) → Q13 (TreeSet)
Key connections:
- Q11 ↔ Q14: Set uses Map internally (HashSet = HashMap<E, Object>)
- Q12 ↔ Q15: HashSet internals = HashMap internals
- Q13 ↔ Q16: TreeSet = TreeMap.keySet(), when TreeMap is needed
Topic: Map
Q14 (Map overview) → Q15 (HashMap vs LinkedHashMap vs TreeMap) → Q16 (TreeMap)
↓ ↓ ↓
Q17 (WeakHashMap) Q12 (HashSet internals) Q18-19 (ConcurrentHashMap)
↓
Q20 (CopyOnWriteArrayList)
Key connections:
- Q14 ↔ Q1: Map is technically NOT a Collection, but part of the Framework
- Q15 ↔ Q12: HashMap internals = HashSet internals
- Q17 ↔ Q3 (Memory and GC): WeakReference, GC, SoftReference
- Q18-19 ↔ Q21: CHM vs synchronizedList — different approaches to thread-safety
- Q18 ↔ Q20: CHM for mixed workload, COWAL for read-heavy
Topic: Thread-Safety
Q7 (Vector) → Q21 (synchronized collections) → Q22 (How to get)
↓ ↓ ↓
Q18 (CHM) ←────────────── Q19 (CHM thread-safety) Q20 (CopyOnWriteArrayList)
Key connections:
- Q7 ↔ Q21: Vector — legacy approach, synchronizedList — modern
- Q18 ↔ Q20: CHM = granular locks, COWAL = snapshot
- Q21 ↔ Q26: synchronizedList = fail-fast, CHM = weakly consistent
Topic: Iterators and removal
Q25 (Iterator vs ListIterator) → Q26 (fail-fast vs fail-safe)
↓ ↓
Q27 (CME) ←──────────────────────── Q28 (Proper removal)
↑
Q23-24 (unmodifiableList)
Key connections:
- Q25 ↔ Q28: Iterator.remove() — the correct way to remove
- Q26 ↔ Q27: fail-fast throws CME, fail-safe — does not
- Q23-24 ↔ Q27: unmodifiableList does not protect against CME through view
🎓 Cheat Sheet: What to Know for Each Level
🟢 Junior
- Hierarchy: Collection → List/Set/Queue, Map — in parallel
- ArrayList vs LinkedList: ArrayList for most cases
- HashSet = uniqueness, TreeSet = sorting
- HashMap = key-value, TreeMap = sorted by key
- Vector/Stack — legacy, use ArrayList/ArrayDeque
- Iterator for iteration, cannot remove in for-each
- unmodifiableList = defensive wrapper, not deep immutability
🟡 Middle
- Big O: ArrayList add = amort. O(1), get = O(1); LinkedList get = O(n)
- Cache locality: ArrayList > LinkedList 10-100x on iteration
- HashSet = HashMap internally, treeification at > 8 elements per bucket
- ConcurrentHashMap: CAS + volatile + synchronized, does NOT block reads
- CopyOnWriteArrayList: snapshot, fail-safe, O(n) copy on write
- fail-fast = modCount, CME = bug detector (not synchronization!)
- removeIf() = O(n) for ArrayList, Iterator.remove() = O(n²)
- Comparable = natural order, Comparator = external sorting
🔴 Senior
- System.arraycopy: JVM intrinsic, SIMD, branch prediction
- LinkedList cache miss: each node — a separate object on the heap
- CHM: CounterCells (LongAdder), ForwardingNode, ReservationNode
- WeakHashMap: ReferenceQueue, expungeStaleEntries, Minor GC
- ConcurrentHashMap size(): not a lock, but a counter via CAS
- Timsort: stable sorting, transitivity, overflow
- Spliterator: characteristics (SIZED, DISTINCT, SORTED) for Stream optimization
- Java 21: SequencedCollection/SequencedSet/SequencedMap
📝 Format of Each File
Each file contains:
- 🟢 Junior Level — basic understanding, simple analogies, examples
- 🟡 Middle Level — internals, typical mistakes, practical examples
- 🔴 Senior Level — deep dive, edge cases, production experience, monitoring
- 🎯 Interview Cheat Sheet — key points, frequent questions, red flags, related topics