[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":87,"_73":88,"_35":89},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",121,"title","Views, Wrappers, and Defensive Copies","slug","java-collections-part-25-views-wrappers-defensive","excerpt","Distinguish views (subList, keySet, entrySet) from copies, synchronized wrappers with limitations, checked wrappers for type safety, and defensive API patterns.","# Java Collections Compendium Part 25: Views, Wrappers & Defensive Patterns\n\nMaster collection views and wrapper patterns for robust APIs. Learn when to use subList(), keySet(), and entrySet() views, understand synchronized and checked wrappers, and apply defensive programming to protect your data.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | Views (subList, keySet), Wrappers (synchronized, checked, unmodifiable), Defensive copying |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 1 (Collection Architecture), Part 22 (Immutable Collections) |\n| **Time to Master** | 2-3 hours |\n| **Interview Frequency** | High (API design, thread safety, encapsulation) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Distinguish between views and copies in collection operations\n2. Use synchronized wrappers correctly (and know their limitations)\n3. Apply checked wrappers for runtime type safety\n4. Design APIs with defensive copies for encapsulation\n5. Choose between views, wrappers, and copies for your use case\n\n---\n\n## Production Story: The Synchronized Surprise\n\n### The Incident\n\nOur inventory service used synchronized collections for thread safety, but we still had a race condition:\n\n```java\n// InventoryService.java - The problematic code\n@Service\npublic class InventoryService {\n private final Map stock =\n Collections.synchronizedMap(new HashMap<>());\n\n public boolean reserveItem(String itemId, int quantity) {\n // Check if enough stock\n Integer current = stock.get(itemId);\n if (current != null && current >= quantity) {\n // Reserve the stock\n stock.put(itemId, current - quantity); // Race condition!\n return true;\n }\n return false;\n }\n}\n```\n\n### The Problem\n\n```text\nRace Condition Timeline:\n\nThread A: reserveItem(\"widget\", 5)\nThread B: reserveItem(\"widget\", 5)\n\nStock: widget = 8\n\nT1: Thread A: stock.get(\"widget\") → 8 [synchronized]\nT2: Thread B: stock.get(\"widget\") → 8 [synchronized]\nT3: Thread A: 8 >= 5 ✓ ... continues\nT4: Thread B: 8 >= 5 ✓ ... continues\nT5: Thread A: stock.put(\"widget\", 3) [synchronized]\nT6: Thread B: stock.put(\"widget\", 3) [synchronized]\n\nResult: Both threads reserved 5, but stock only decreased by 5!\n Expected: stock = -2 (error) or one thread rejected\n Actual: stock = 3, 10 items \"reserved\" from 8!\n\nBusiness Impact:\n├─ Oversold 2 items\n├─ Customer complaints when orders can't be fulfilled\n├─ Manual reconciliation required\n└─ Lost customer trust\n```\n\n### The Real Solution\n\n```java\n// InventoryService.java - Thread-safe compound operation\n@Service\npublic class InventoryService {\n private final ConcurrentHashMap stock = new ConcurrentHashMap<>();\n\n public boolean reserveItem(String itemId, int quantity) {\n // Atomic compound operation\n return stock.computeIfPresent(itemId, (key, current) -> {\n if (current >= quantity) {\n return current - quantity; // Atomically update\n }\n return current; // No change if insufficient\n }) != null;\n\n // Better: Return whether reservation succeeded\n AtomicBoolean reserved = new AtomicBoolean(false);\n stock.computeIfPresent(itemId, (key, current) -> {\n if (current >= quantity) {\n reserved.set(true);\n return current - quantity;\n }\n return current;\n });\n return reserved.get();\n }\n}\n```\n\n### The Lesson\n\n```text\nsynchronizedMap() guarantees:\n├─ Individual operations are atomic\n├─ get(), put(), remove() don't interleave\n└─ Memory visibility between threads\n\nsynchronizedMap() does NOT guarantee:\n├─ Compound operations are atomic (check-then-act)\n├─ Iteration safety (must manually synchronize)\n└─ Protection against logical race conditions\n\nSolution: Use ConcurrentHashMap.compute*() for atomic compound operations\n```\n\n---\n\n## Mental Model: Views vs Copies vs Wrappers\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ VIEWS vs COPIES vs WRAPPERS │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ VIEW = Window into original data │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Original: [A, B, C, D, E] │ │\n│ │ ↑ ↑ │ │\n│ │ │ │ │ │\n│ │ subList(1,4) └─────┴─→ [B, C, D] (view into same array) │ │\n│ │ │ │\n│ │ Changes to view → affect original │ │\n│ │ Changes to original → affect view (may cause exception) │ │\n│ │ No memory allocation for elements │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ COPY = Independent duplicate │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Original: [A, B, C, D, E] │ │\n│ │ │ │\n│ │ new ArrayList<>(subList(1,4)) → [B, C, D] (separate) │ │\n│ │ │ │\n│ │ Changes to copy → don't affect original │ │\n│ │ Changes to original → don't affect copy │ │\n│ │ Memory allocated for all elements │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ WRAPPER = Delegation with behavior modification │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ │ │\n│ │ Original: [A, B, C] │ │\n│ │ ↑ │ │\n│ │ │ delegates │ │\n│ │ │ │ │\n│ │ Wrapper ──→ Blocks mutations (unmodifiable) │ │\n│ │ ──→ Adds synchronization (synchronized) │ │\n│ │ ──→ Validates types (checked) │ │\n│ │ │ │\n│ │ Same data, different interface/behavior │ │\n│ │ │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: Collection Views\n\n### subList() - List View\n\n```java\nList list = new ArrayList<>(List.of(\"A\", \"B\", \"C\", \"D\", \"E\"));\n\n// subList returns a VIEW, not a copy\nList sub = list.subList(1, 4); // [B, C, D]\n\n// Changes to view affect original\nsub.set(0, \"X\");\nSystem.out.println(list); // [A, X, C, D, E]\nSystem.out.println(sub); // [X, C, D]\n\nsub.add(\"Y\");\nSystem.out.println(list); // [A, X, C, D, Y, E]\nSystem.out.println(sub); // [X, C, D, Y]\n\nsub.clear();\nSystem.out.println(list); // [A, E]\nSystem.out.println(sub); // []\n\n// BUT: Structural modification to original invalidates view\nlist.add(\"Z\");\nsub.get(0); // ConcurrentModificationException!\n```\n\n### Map Views: keySet(), values(), entrySet()\n\n```java\nMap map = new HashMap<>();\nmap.put(\"one\", 1);\nmap.put(\"two\", 2);\nmap.put(\"three\", 3);\n\n// All three return VIEWS backed by the map\nSet keys = map.keySet();\nCollection values = map.values();\nSet> entries = map.entrySet();\n\n// Removing from view removes from map\nkeys.remove(\"one\");\nSystem.out.println(map); // {two=2, three=3}\n\n// Removing via iterator\nIterator it = values.iterator();\nwhile (it.hasNext()) {\n if (it.next() == 2) {\n it.remove(); // Removes from map!\n }\n}\nSystem.out.println(map); // {three=3}\n\n// BUT: Cannot add via keySet() or values()\nkeys.add(\"four\"); // UnsupportedOperationException!\nvalues.add(4); // UnsupportedOperationException!\n\n// Adding to map reflects in views\nmap.put(\"four\", 4);\nSystem.out.println(keys); // [three, four]\n```\n\n### NavigableSet/Map Views\n\n```java\nTreeSet set = new TreeSet<>(List.of(1, 3, 5, 7, 9));\n\n// headSet, tailSet, subSet return VIEWS\nNavigableSet head = set.headSet(5, false); // [1, 3]\nNavigableSet tail = set.tailSet(5, true); // [5, 7, 9]\nNavigableSet sub = set.subSet(3, true, 7, false); // [3, 5]\n\n// Views have range restrictions\nhead.add(4); // OK, 4 < 5\nhead.add(6); // IllegalArgumentException! 6 >= 5\n\n// descendingSet() is a view too\nNavigableSet desc = set.descendingSet();\nSystem.out.println(desc); // [9, 7, 5, 3, 1]\n\ndesc.add(0);\nSystem.out.println(set); // [0, 1, 3, 5, 7, 9]\n```\n\n---\n\n## Deep Dive: Synchronized Wrappers\n\n### Creating Synchronized Collections\n\n```java\n// Wrap any collection to make it thread-safe\nList syncList = Collections.synchronizedList(new ArrayList<>());\nSet syncSet = Collections.synchronizedSet(new HashSet<>());\nMap syncMap = Collections.synchronizedMap(new HashMap<>());\n\n// Sorted variants\nSortedSet syncSortedSet = Collections.synchronizedSortedSet(new TreeSet<>());\nSortedMap syncSortedMap = Collections.synchronizedSortedMap(new TreeMap<>());\n\n// Navigable variants (Java 8+)\nNavigableSet syncNavSet = Collections.synchronizedNavigableSet(new TreeSet<>());\nNavigableMap syncNavMap = Collections.synchronizedNavigableMap(new TreeMap<>());\n```\n\n### How Synchronized Wrappers Work\n\n```java\n// Simplified implementation\npublic class SynchronizedList implements List {\n private final List list;\n private final Object mutex;\n\n SynchronizedList(List list) {\n this.list = list;\n this.mutex = this; // Uses itself as lock\n }\n\n public E get(int index) {\n synchronized (mutex) {\n return list.get(index);\n }\n }\n\n public E set(int index, E element) {\n synchronized (mutex) {\n return list.set(index, element);\n }\n }\n\n public boolean add(E element) {\n synchronized (mutex) {\n return list.add(element);\n }\n }\n\n // Iterator is NOT automatically synchronized!\n public Iterator iterator() {\n return list.iterator(); // Must manually synchronize iteration\n }\n}\n```\n\n### Manual Synchronization for Iteration\n\n```java\nList syncList = Collections.synchronizedList(new ArrayList<>());\n\n// ❌ WRONG: Iterator not synchronized\nfor (String s : syncList) { // ConcurrentModificationException possible!\n process(s);\n}\n\n// ✅ CORRECT: Manual synchronization block\nsynchronized (syncList) {\n for (String s : syncList) {\n process(s);\n }\n}\n\n// ✅ ALSO CORRECT: Stream (creates snapshot for iteration)\nsyncList.stream().forEach(this::process);\n\n// For synchronized map, sync on the map itself\nMap syncMap = Collections.synchronizedMap(new HashMap<>());\nsynchronized (syncMap) {\n for (Map.Entry entry : syncMap.entrySet()) {\n process(entry);\n }\n}\n```\n\n### Limitations of Synchronized Wrappers\n\n```java\n// Problem 1: Compound operations are NOT atomic\nMap> syncMap =\n Collections.synchronizedMap(new HashMap<>());\n\n// ❌ RACE CONDITION: check-then-act\nif (!syncMap.containsKey(\"key\")) {\n syncMap.put(\"key\", new ArrayList<>()); // Another thread might add between check and put!\n}\n\n// ✅ SOLUTION: Use ConcurrentHashMap.computeIfAbsent\nConcurrentMap> concurrentMap = new ConcurrentHashMap<>();\nconcurrentMap.computeIfAbsent(\"key\", k -> new ArrayList<>());\n\n// Problem 2: No atomic get-and-modify\n// ❌ RACE CONDITION\nInteger value = syncMap.get(\"counter\");\nsyncMap.put(\"counter\", value + 1);\n\n// ✅ SOLUTION: Use ConcurrentHashMap.compute\nconcurrentMap.compute(\"counter\", (k, v) -> v == null ? 1 : v + 1);\n\n// Problem 3: Views inherit the lock but need manual sync\nSet keys = syncMap.keySet(); // View\nsynchronized (syncMap) { // Must sync on original map, not keys!\n for (String key : keys) {\n process(key);\n }\n}\n```\n\n---\n\n## Deep Dive: Checked Wrappers\n\n### Purpose of Checked Wrappers\n\n```java\n// Checked wrappers enforce type safety at runtime\n// Useful when dealing with raw types or untyped collections\n\n// Without checked wrapper - heap pollution possible\nList rawList = new ArrayList();\nList stringList = rawList; // Unchecked warning, but compiles\nrawList.add(123); // Oops! Added Integer to \"String\" list\nString s = stringList.get(0); // ClassCastException at runtime!\n\n// With checked wrapper - immediate failure on wrong type\nList checkedList = Collections.checkedList(new ArrayList<>(), String.class);\ncheckedList.add(\"hello\"); // OK\ncheckedList.add((Object) 123); // ClassCastException immediately!\n```\n\n### Available Checked Wrappers\n\n```java\n// All checked wrapper factory methods\nCollections.checkedCollection(collection, type);\nCollections.checkedList(list, type);\nCollections.checkedSet(set, type);\nCollections.checkedSortedSet(sortedSet, type);\nCollections.checkedNavigableSet(navigableSet, type);\nCollections.checkedMap(map, keyType, valueType);\nCollections.checkedSortedMap(sortedMap, keyType, valueType);\nCollections.checkedNavigableMap(navigableMap, keyType, valueType);\nCollections.checkedQueue(queue, type);\n\n// Example usage\nList safe = Collections.checkedList(new ArrayList<>(), String.class);\nMap safeMap = Collections.checkedMap(\n new HashMap<>(), String.class, Integer.class\n);\n```\n\n### When to Use Checked Wrappers\n\n```java\n// Use case 1: Accepting collections from untrusted code\npublic void processData(List rawInput) {\n // We need String list but don't trust input\n List checked = Collections.checkedList(new ArrayList<>(), String.class);\n for (Object item : rawInput) {\n checked.add((String) item); // Will fail fast on wrong type\n }\n // Now safe to use as List\n}\n\n// Use case 2: Debugging type pollution issues\n// Wrap collection at creation to catch when wrong type added\nList debugList = Collections.checkedList(\n new ArrayList<>(), String.class\n);\n// Now ClassCastException will show exactly where wrong type was added\n\n// Use case 3: Legacy code integration\npublic void legacyMethod(List list) { // Raw type from old code\n List safe = Collections.checkedList(list, String.class);\n // ...\n}\n```\n\n---\n\n## Deep Dive: Defensive Copying\n\n### The Problem: Escaping References\n\n```java\n// ❌ DANGEROUS: Returns internal collection\npublic class UserRepository {\n private final List users = new ArrayList<>();\n\n public List getUsers() {\n return users; // Exposes internal state!\n }\n}\n\n// Caller can corrupt internal state:\nList users = repo.getUsers();\nusers.clear(); // Oops! Cleared the repository!\nusers.add(new User(\"Hacker\")); // Injected unauthorized user!\n```\n\n### Defensive Copy Patterns\n\n```java\n// Pattern 1: Return unmodifiable view (cheapest, but shares data)\npublic List getUsers() {\n return Collections.unmodifiableList(users);\n}\n// Caller can't modify, but if we modify users internally, they see changes\n\n// Pattern 2: Return defensive copy (safest, more memory)\npublic List getUsers() {\n return new ArrayList<>(users);\n}\n// Caller gets their own copy, no connection to internal state\n\n// Pattern 3: Return immutable copy (safest + immutable, Java 10+)\npublic List getUsers() {\n return List.copyOf(users);\n}\n// Immutable copy, clearly communicates \"don't try to modify\"\n\n// Pattern 4: Stream for lazy processing\npublic Stream users() {\n return users.stream();\n}\n// No direct collection access, caller processes elements\n```\n\n### Defensive Copy on Input\n\n```java\n// ❌ DANGEROUS: Stores reference to caller's collection\npublic class Report {\n private List items;\n\n public Report(List items) {\n this.items = items; // Caller can still modify!\n }\n}\n\nList original = new ArrayList<>();\noriginal.add(\"A\");\nReport report = new Report(original);\noriginal.add(\"B\"); // Also adds to report.items!\n\n// ✅ SAFE: Defensive copy on input\npublic class Report {\n private final List items;\n\n public Report(List items) {\n this.items = new ArrayList<>(items); // Our own copy\n }\n\n // Or immutable:\n public Report(List items) {\n this.items = List.copyOf(items); // Immutable copy\n }\n}\n```\n\n### Records with Collections\n\n```java\n// Records need defensive copies for collection fields!\n\n// ❌ DANGEROUS: Record exposes mutable collection\nrecord OrderBad(String id, List items) {}\n\nList mutableItems = new ArrayList<>();\nOrderBad order = new OrderBad(\"1\", mutableItems);\nmutableItems.add(new Item(\"hacked\")); // Modifies order!\norder.items().clear(); // Also modifies!\n\n// ✅ SAFE: Defensive copy in compact constructor\nrecord OrderGood(String id, List items) {\n public OrderGood {\n items = List.copyOf(items); // Immutable copy\n }\n}\n\n// Now safe:\nList mutableItems = new ArrayList<>();\nmutableItems.add(new Item(\"A\"));\nOrderGood order = new OrderGood(\"1\", mutableItems);\nmutableItems.add(new Item(\"B\")); // Doesn't affect order\norder.items().add(new Item(\"C\")); // UnsupportedOperationException!\n```\n\n---\n\n## Deep Dive: Choosing the Right Pattern\n\n### Decision Matrix\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ WHEN TO USE WHAT │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ Need to... Use... │\n│ ────────────────────────────────────────────────────────────── │\n│ Expose part of list subList() view │\n│ Expose map keys keySet() view │\n│ Iterate backward reversed() view (Java 21) │\n│ │\n│ Prevent caller modification unmodifiableXxx() wrapper │\n│ OR List.copyOf() (Java 10+) │\n│ │\n│ Make thread-safe ConcurrentHashMap (prefer) │\n│ (compound ops) OR synchronizedXxx() + manual sync │\n│ │\n│ Enforce runtime type safety checkedXxx() wrapper │\n│ │\n│ Isolate from caller Defensive copy (new ArrayList<>()) │\n│ OR List.copyOf() │\n│ │\n│ Return empty collection List.of(), Set.of(), Map.of() │\n│ (immutable) OR Collections.emptyXxx() │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### Performance Considerations\n\n```java\n// View: O(1) creation, shares memory\nList view = list.subList(0, 10);\n\n// Unmodifiable wrapper: O(1) creation, shares memory\nList unmod = Collections.unmodifiableList(list);\n\n// Defensive copy: O(n) creation, separate memory\nList copy = new ArrayList<>(list);\n\n// For large lists (1M elements):\n// View creation: ~0 ms, 0 bytes additional\n// Wrapper creation: ~0 ms, ~48 bytes additional (wrapper object)\n// Copy creation: ~50 ms, ~4 MB additional\n\n// Trade-off: Memory vs Isolation\n// Views/Wrappers: Fast, but changes propagate\n// Copies: Slower, but completely independent\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Modifying Original After Creating subList\n\n```java\n// ❌ WRONG: Structural modification invalidates view\nList list = new ArrayList<>(List.of(\"A\", \"B\", \"C\", \"D\"));\nList sub = list.subList(1, 3);\n\nlist.add(\"E\"); // Structural modification!\nsub.get(0); // ConcurrentModificationException!\n\n// ✅ CORRECT: Create copy if you need to modify original\nList subCopy = new ArrayList<>(list.subList(1, 3));\nlist.add(\"E\"); // OK\nsubCopy.get(0); // OK, independent copy\n```\n\n### Mistake 2: Assuming synchronizedMap Handles Compound Operations\n\n```java\n// ❌ WRONG: Not atomic\nMap map = Collections.synchronizedMap(new HashMap<>());\nInteger val = map.get(\"key\");\nif (val == null) {\n map.put(\"key\", 1);\n} else {\n map.put(\"key\", val + 1);\n}\n\n// ✅ CORRECT: Use ConcurrentHashMap\nConcurrentMap map = new ConcurrentHashMap<>();\nmap.merge(\"key\", 1, Integer::sum);\n// Or\nmap.compute(\"key\", (k, v) -> v == null ? 1 : v + 1);\n```\n\n### Mistake 3: Forgetting to Sync Iteration\n\n```java\n// ❌ WRONG: Iterator not synchronized\nList syncList = Collections.synchronizedList(new ArrayList<>());\n// Thread A\nfor (String s : syncList) { // Not synchronized!\n process(s);\n}\n// Thread B\nsyncList.add(\"new\"); // Concurrent modification!\n\n// ✅ CORRECT: Sync the iteration\nsynchronized (syncList) {\n for (String s : syncList) {\n process(s);\n }\n}\n```\n\n### Mistake 4: Thinking unmodifiable = Immutable\n\n```java\n// ❌ WRONG: unmodifiable is just a view\nList original = new ArrayList<>();\noriginal.add(\"A\");\nList unmod = Collections.unmodifiableList(original);\n\noriginal.add(\"B\"); // Modifies \"unmodifiable\" list!\nSystem.out.println(unmod); // [A, B]\n\n// ✅ CORRECT: Use copyOf for true immutability\nList immutable = List.copyOf(original);\noriginal.add(\"C\"); // Doesn't affect immutable\nSystem.out.println(immutable); // [A, B]\n```\n\n### Mistake 5: Wrong Object for Synchronization\n\n```java\n// ❌ WRONG: Syncing on view instead of backing collection\nMap map = Collections.synchronizedMap(new HashMap<>());\nSet keys = map.keySet();\n\nsynchronized (keys) { // Wrong object!\n for (String key : keys) {\n process(key);\n }\n}\n\n// ✅ CORRECT: Sync on the map itself\nsynchronized (map) { // Correct object\n for (String key : keys) {\n process(key);\n }\n}\n```\n\n---\n\n## 🐛 Debug This\n\n### Challenge 1: The Disappearing Elements\n\n```java\nMap map = new HashMap<>();\nmap.put(\"A\", 1);\nmap.put(\"B\", 2);\nmap.put(\"C\", 3);\n\nSet keys = map.keySet();\nfor (String key : keys) {\n if (key.equals(\"B\")) {\n keys.remove(key); // What happens?\n }\n}\n```\n\n**✅ Answer:**\n\n`ConcurrentModificationException`! You're modifying the collection while iterating.\n\n**Fix:**\n```java\n// Option 1: Use iterator.remove()\nIterator it = keys.iterator();\nwhile (it.hasNext()) {\n if (it.next().equals(\"B\")) {\n it.remove();\n }\n}\n\n// Option 2: Use removeIf\nkeys.removeIf(key -> key.equals(\"B\"));\n\n// Option 3: Remove from map directly\nmap.remove(\"B\");\n```\n\n### Challenge 2: The Unsynchronized Stream\n\n```java\nList list = Collections.synchronizedList(new ArrayList<>());\nlist.addAll(List.of(\"A\", \"B\", \"C\"));\n\n// Thread 1\nlist.parallelStream().forEach(s -> process(s));\n\n// Thread 2\nlist.add(\"D\");\n\n// Is this safe?\n```\n\n**✅ Answer:**\n\nNo! Parallel stream iteration is not automatically synchronized. While `synchronizedList` synchronizes individual operations, the stream iteration reads multiple elements, and concurrent modification can cause issues.\n\n**Fix:**\n```java\n// Option 1: Sync the stream operation\nsynchronized (list) {\n list.stream().forEach(s -> process(s)); // Use sequential stream\n}\n\n// Option 2: Create a snapshot\nList snapshot = List.copyOf(list);\nsnapshot.parallelStream().forEach(s -> process(s));\n\n// Option 3: Use CopyOnWriteArrayList (if writes are rare)\nList cowList = new CopyOnWriteArrayList<>();\ncowList.parallelStream().forEach(s -> process(s)); // Safe, iterates snapshot\n```\n\n### Challenge 3: The Checked Collection Bypass\n\n```java\nList checked = Collections.checkedList(new ArrayList<>(), String.class);\nList raw = checked; // Raw type\nraw.add(123); // What happens?\n```\n\n**✅ Answer:**\n\n`ClassCastException`! The checked wrapper validates types at runtime, regardless of how you obtain a reference to it. This is exactly what checked wrappers are for - catching this kind of type pollution.\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Safe Configuration Manager\n\nCreate a thread-safe configuration manager:\n\n```java\npublic class ConfigManager {\n // Store key-value configurations\n // Support: get, set, getAll (returns immutable snapshot)\n // Must be thread-safe for all operations\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class ConfigManager {\n private final ConcurrentHashMap config = new ConcurrentHashMap<>();\n\n public String get(String key) {\n return config.get(key);\n }\n\n public String get(String key, String defaultValue) {\n return config.getOrDefault(key, defaultValue);\n }\n\n public void set(String key, String value) {\n if (key == null || value == null) {\n throw new IllegalArgumentException(\"Key and value must not be null\");\n }\n config.put(key, value);\n }\n\n public String setIfAbsent(String key, String value) {\n if (key == null || value == null) {\n throw new IllegalArgumentException(\"Key and value must not be null\");\n }\n return config.putIfAbsent(key, value);\n }\n\n public void remove(String key) {\n config.remove(key);\n }\n\n public Map getAll() {\n return Map.copyOf(config); // Immutable snapshot\n }\n\n public void updateAll(Map updates) {\n updates.forEach((k, v) -> {\n if (k != null && v != null) {\n config.put(k, v);\n }\n });\n }\n}\n```\n\n### Exercise 2: Paginated View\n\nCreate a view that provides paginated access to a list:\n\n```java\npublic class PaginatedView {\n public PaginatedView(List source, int pageSize);\n public List getPage(int pageNumber); // Returns view, not copy\n public int getTotalPages();\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class PaginatedView {\n private final List source;\n private final int pageSize;\n\n public PaginatedView(List source, int pageSize) {\n if (source == null) throw new IllegalArgumentException(\"source required\");\n if (pageSize <= 0) throw new IllegalArgumentException(\"pageSize must be positive\");\n this.source = source;\n this.pageSize = pageSize;\n }\n\n public List getPage(int pageNumber) {\n if (pageNumber < 0) {\n throw new IllegalArgumentException(\"Page number must be non-negative\");\n }\n\n int start = pageNumber * pageSize;\n if (start >= source.size()) {\n return List.of(); // Empty page\n }\n\n int end = Math.min(start + pageSize, source.size());\n return Collections.unmodifiableList(source.subList(start, end));\n }\n\n public int getTotalPages() {\n return (source.size() + pageSize - 1) / pageSize; // Ceiling division\n }\n\n public int getPageSize() {\n return pageSize;\n }\n\n public int getTotalElements() {\n return source.size();\n }\n\n // Check if page exists\n public boolean hasPage(int pageNumber) {\n return pageNumber >= 0 && pageNumber < getTotalPages();\n }\n}\n```\n\n### Exercise 3: Type-Safe Registry\n\nCreate a registry that stores objects by class type with runtime type safety:\n\n```java\npublic class TypeSafeRegistry {\n public void register(Class type, T instance);\n public T get(Class type);\n public List getAll(Class type); // Returns immutable list\n}\n```\n\n**✅ Solution:**\n\n```java\npublic class TypeSafeRegistry {\n private final Map, List

Unmodifiablelist

Views, Wrappers, and Defensive Copies