# Java Collection Framework – Quick Summary The **Java Collection Framework** provides a unified architecture to store, manipulate, and process groups of objects. It includes interfaces, implementations, and utility classes. ## Core Hierarchy - **Collection** (root interface for List, Set, Queue) - **Map** (separate hierarchy for key-value pairs) ### 1. List (ordered, allows duplicates, index-based access) - **ArrayList** → fast random access (O(1)), slow middle insert/remove - **LinkedList** → fast insert/delete at ends, slow random access, also implements Deque - **Vector** → synchronized (legacy, rarely used today) ### 2. Set (no duplicates) - **HashSet** → fastest (O(1)), no order - **LinkedHashSet** → maintains insertion order - **TreeSet** → sorted (natural order or Comparator), O(log n) ### 3. Map (key → value, unique keys) - **HashMap** → fastest (O(1) average), no order - **LinkedHashMap** → insertion order (or access order mode) - **TreeMap** → sorted by keys, O(log n) - **Hashtable** → legacy synchronized version (rarely used now) ### 4. Queue / Deque - **PriorityQueue** → priority-based ordering (heap) - **ArrayDeque** → fastest general-purpose deque/stack/queue (preferred over LinkedList) - **LinkedList** → can also act as Queue/Deque ## Quick Decision Guide | Requirement | Best Choice(s) | |------------------------------------|-------------------------------------| | Fast index access, occasional add/remove | **ArrayList** | | Frequent add/remove at both ends | **ArrayDeque** or **LinkedList** | | Uniqueness, no order needed | **HashSet** | | Uniqueness + insertion order | **LinkedHashSet** | | Uniqueness + sorted order | **TreeSet** | | Key-value pairs, fastest access | **HashMap** | | Key-value + insertion order | **LinkedHashMap** | | Key-value + sorted keys | **TreeMap** | | Thread-safe map (concurrent) | **ConcurrentHashMap** | ## Important Utilities - `Collections.sort()`, `reverse()`, `shuffle()`, `min()`, `max()`, `synchronizedList/Map/Set()`, `unmodifiable...()` - Enhanced for-loop, `Iterator`, Java 8+ **Stream API** ## Thread Safety - Most collections are **not thread-safe** by default - Options: `Collections.synchronizedXxx()`, `java.util.concurrent` classes (`ConcurrentHashMap`, `CopyOnWriteArrayList`, etc.), or manual synchronization ## Code Examples ```java import java.util.*; public class CollectionExamples { public static void main(String[] args) { // 1. ArrayList – ordered, allows duplicates List names = new ArrayList<>(); names.add("Alice"); names.add("Bob"); names.add("Alice"); // duplicate allowed System.out.println("ArrayList: " + names); // [Alice, Bob, Alice] // 2. HashSet – no duplicates, no order Set numbers = new HashSet<>(); numbers.add(42); numbers.add(7); numbers.add(42); // ignored System.out.println("HashSet: " + numbers); // e.g. [7, 42] // 3. LinkedHashSet – insertion order + uniqueness Set orderedUnique = new LinkedHashSet<>(); orderedUnique.add("cat"); orderedUnique.add("dog"); orderedUnique.add("cat"); orderedUnique.add("bird"); System.out.println("LinkedHashSet: " + orderedUnique); // [cat, dog, bird] // 4. TreeSet – sorted Set sorted = new TreeSet<>(); sorted.add(50); sorted.add(10); sorted.add(30); System.out.println("TreeSet: " + sorted); // [10, 30, 50] // 5. HashMap – key-value Map ages = new HashMap<>(); ages.put("Alice", 28); ages.put("Bob", 34); ages.put("Charlie", 19); System.out.println("HashMap: " + ages); // 6. LinkedHashMap – insertion order Map favorites = new LinkedHashMap<>(); favorites.put("color", "blue"); favorites.put("food", "pizza"); favorites.put("city", "Kyoto"); System.out.println("LinkedHashMap (order preserved): " + favorites); // 7. PriorityQueue – natural ordering Queue priority = new PriorityQueue<>(); priority.offer(50); priority.offer(10); priority.offer(30); System.out.println("PriorityQueue poll: " + priority.poll()); // 10 (smallest) // 8. ArrayDeque as stack Deque stack = new ArrayDeque<>(); stack.push("bottom"); stack.push("middle"); stack.push("top"); System.out.println("Pop from stack: " + stack.pop()); // top } }

Blog