[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":89,"_73":90,"_35":91},"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",100,"title","Iterators and Iteration Patterns","slug","java-collections-part-4-iterators-and-iteration","excerpt","Master Iterator internals, fail-fast mechanisms, ConcurrentModificationException, ListIterator for bidirectional traversal, and Spliterator for parallel processing.","# Java Collections Compendium Part 4: Iterators, Spliterators & Iteration Patterns\n\nMaster the art of traversing collections safely and efficiently. From the humble Iterator to the parallel-ready Spliterator, understand how Java's iteration abstractions work under the hood, why ConcurrentModificationException exists, and when parallel streams actually help.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | Iterator, ListIterator, Spliterator, and iteration patterns |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 1 (Framework Architecture), Part 2 (Generics) |\n| **Time to Master** | 3-4 hours |\n| **Interview Frequency** | Very High (fail-fast, ConcurrentModificationException) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Understand Iterator internals and the fail-fast mechanism\n2. Use ListIterator for bidirectional traversal and modification\n3. Master Spliterator for parallel processing\n4. Choose the right iteration pattern for each scenario\n5. Avoid ConcurrentModificationException in production code\n\n---\n\n## Production Story: The Mysterious ConcurrentModificationException\n\n### The Incident\n\nIt was 2 AM when the alerts fired. Our payment processing service was throwing `ConcurrentModificationException` intermittently, causing transactions to fail. The error rate was climbing: 0.1%, 0.5%, 2%...\n\nThe stack trace pointed to seemingly innocent code:\n\n```java\n// PaymentProcessor.java - The problematic code\npublic void processPayments(List pendingPayments) {\n for (Payment payment : pendingPayments) {\n if (payment.isExpired()) {\n pendingPayments.remove(payment); // 💥 ConcurrentModificationException!\n continue;\n }\n\n PaymentResult result = gateway.process(payment);\n if (result.isSuccess()) {\n pendingPayments.remove(payment); // 💥 Also dangerous!\n }\n }\n}\n```\n\n### Why It Worked... Sometimes\n\nThe code had been in production for months. Why did it suddenly break?\n\nThe `ConcurrentModificationException` happens when you modify a collection while iterating with an enhanced for-loop. But here's the catch: **the exception isn't guaranteed to be thrown**.\n\n```java\n// Enhanced for-loop is syntactic sugar for:\nIterator iterator = pendingPayments.iterator();\nwhile (iterator.hasNext()) {\n Payment payment = iterator.next(); // Checks modCount here\n // ...\n}\n```\n\nThe iterator checks `modCount` (modification count) at each `next()` call. If it differs from `expectedModCount`, exception is thrown. But if you remove the **last element** or certain elements in specific positions, the iteration might complete before the check triggers.\n\nOur traffic pattern changed - we started processing more expired payments, which happened to be in the middle of lists rather than at the end.\n\n### The Root Cause\n\nLet me show you what happens inside:\n\n```java\n// ArrayList Iterator internals (simplified)\nprivate class Itr implements Iterator {\n int cursor; // Index of next element\n int lastRet = -1; // Index of last returned element\n int expectedModCount = modCount;\n\n public E next() {\n checkForComodification(); // 💥 Throws if modCount changed\n // ... return element\n }\n\n final void checkForComodification() {\n if (modCount != expectedModCount)\n throw new ConcurrentModificationException();\n }\n}\n```\n\nWhen you call `list.remove()` during iteration:\n1. The list's `modCount` increments\n2. The iterator's `expectedModCount` stays the same\n3. Next `iterator.next()` detects the mismatch\n4. Exception thrown!\n\n### The Fix\n\n```java\n// Fix 1: Use Iterator.remove()\npublic void processPayments(List pendingPayments) {\n Iterator iterator = pendingPayments.iterator();\n while (iterator.hasNext()) {\n Payment payment = iterator.next();\n if (payment.isExpired()) {\n iterator.remove(); // ✅ Safe - updates expectedModCount\n continue;\n }\n\n PaymentResult result = gateway.process(payment);\n if (result.isSuccess()) {\n iterator.remove(); // ✅ Safe\n }\n }\n}\n\n// Fix 2: Use removeIf() (Java 8+, cleaner for simple cases)\npublic void removeExpiredPayments(List payments) {\n payments.removeIf(Payment::isExpired); // ✅ Safe and concise\n}\n\n// Fix 3: Collect and remove separately\npublic void processPayments(List pendingPayments) {\n List toRemove = new ArrayList<>();\n\n for (Payment payment : pendingPayments) {\n if (payment.isExpired() || gateway.process(payment).isSuccess()) {\n toRemove.add(payment);\n }\n }\n\n pendingPayments.removeAll(toRemove); // ✅ Safe - after iteration\n}\n```\n\n### Impact and Lessons\n\n**Immediate Impact:**\n- 47 failed transactions during the 23-minute incident\n- $12,000 in delayed payments\n- 3 support escalations\n\n**Lessons Learned:**\n1. Never modify collections during enhanced for-loop iteration\n2. The bug can hide for months before manifesting\n3. Use `Iterator.remove()` or `removeIf()` for safe removal\n4. Code review should flag any `collection.remove()` inside loops\n\n---\n\n## Mental Model: The Library Reading Room\n\nThink of iteration like reading books in a library reading room:\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ LIBRARY READING ROOM │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ 📚 Bookshelf (Collection) │\n│ ┌─────┬─────┬─────┬─────┬─────┐ │\n│ │Book1│Book2│Book3│Book4│Book5│ modCount: 5 │\n│ └─────┴─────┴─────┴─────┴─────┘ │\n│ │\n│ 👤 Reader with Bookmark (Iterator) │\n│ ┌─────────────────────────────────┐ │\n│ │ Current Position: Book 2 │ │\n│ │ Expected Shelf Version: 5 │ ← Must match modCount │\n│ │ Last Book Read: Book 1 │ │\n│ └─────────────────────────────────┘ │\n│ │\n│ 📋 Rules: │\n│ • Reader can return current book (remove via iterator) │\n│ • If librarian changes shelf, reader's bookmark invalid! │\n│ • Reader must start fresh if shelf changed │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### Iterator = Reader with Bookmark\n- **Position tracking**: Knows which book is current\n- **Version checking**: Remembers shelf arrangement\n- **Safe removal**: Can return the book they're holding\n\n### ConcurrentModificationException = \"Shelf Changed!\"\n- Reader expected 5 books, now there are 4\n- Bookmark position might be invalid\n- Must restart the reading session\n\n### Spliterator = Multiple Readers Sharing Work\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ PARALLEL READING ROOM │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ 📚 Bookshelf (Large Collection) │\n│ ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐ │\n│ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ │\n│ └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘ │\n│ │\n│ 📖 trySplit() - Divide the work: │\n│ │\n│ Reader A (original) Reader B (split off) │\n│ ┌─────┬─────┬─────┬─────┐ ┌─────┬─────┬─────┬─────┐ │\n│ │ 1 │ 2 │ 3 │ 4 │ │ 5 │ 6 │ 7 │ 8 │ │\n│ └─────┴─────┴─────┴─────┘ └─────┴─────┴─────┴─────┘ │\n│ │\n│ Both readers work independently, in parallel! │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: Iterator Internals\n\n### Iterator Interface\n\n```java\npublic interface Iterator {\n boolean hasNext(); // More elements?\n E next(); // Get next element\n\n default void remove() { // Remove last returned element\n throw new UnsupportedOperationException(\"remove\");\n }\n\n default void forEachRemaining(Consumer action) {\n Objects.requireNonNull(action);\n while (hasNext())\n action.accept(next());\n }\n}\n```\n\n### ArrayList Iterator Implementation\n\n```java\n// Simplified from actual JDK source\nprivate class Itr implements Iterator {\n int cursor; // Index of next element to return\n int lastRet = -1; // Index of last element returned; -1 if none\n int expectedModCount = modCount;\n\n public boolean hasNext() {\n return cursor != size;\n }\n\n @SuppressWarnings(\"unchecked\")\n public E next() {\n checkForComodification();\n int i = cursor;\n if (i >= size)\n throw new NoSuchElementException();\n Object[] elementData = ArrayList.this.elementData;\n if (i >= elementData.length)\n throw new ConcurrentModificationException();\n cursor = i + 1;\n return (E) elementData[lastRet = i];\n }\n\n public void remove() {\n if (lastRet < 0)\n throw new IllegalStateException();\n checkForComodification();\n\n try {\n ArrayList.this.remove(lastRet);\n cursor = lastRet;\n lastRet = -1;\n expectedModCount = modCount; // 🔑 Sync with collection!\n } catch (IndexOutOfBoundsException ex) {\n throw new ConcurrentModificationException();\n }\n }\n\n final void checkForComodification() {\n if (modCount != expectedModCount)\n throw new ConcurrentModificationException();\n }\n}\n```\n\n### Why Iterator.remove() is Safe\n\n```text\nState BEFORE remove():\n┌─────────────────────────────────────────────────────────────────────┐\n│ ArrayList: │\n│ elementData: [A, B, C, D, E] size: 5 modCount: 10 │\n│ │\n│ Iterator: │\n│ cursor: 3 lastRet: 2 (pointing to C) expectedModCount: 10 │\n│ ↑ │\n│ \"I just returned C\" │\n└─────────────────────────────────────────────────────────────────────┘\n\nAfter iterator.remove():\n┌─────────────────────────────────────────────────────────────────────┐\n│ ArrayList: │\n│ elementData: [A, B, D, E, _] size: 4 modCount: 11 │\n│ │\n│ Iterator: │\n│ cursor: 2 lastRet: -1 expectedModCount: 11 ← UPDATED! │\n│ ↑ │\n│ \"Next element is D (shifted down)\" │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\nThe key insight: `Iterator.remove()` updates `expectedModCount` to match the new `modCount`, keeping them synchronized.\n\n---\n\n## Deep Dive: ListIterator\n\n`ListIterator` extends `Iterator` with bidirectional traversal and modification:\n\n```java\npublic interface ListIterator extends Iterator {\n // Query operations\n boolean hasNext();\n E next();\n boolean hasPrevious(); // Can go backward?\n E previous(); // Get previous element\n int nextIndex(); // Index that next() would return\n int previousIndex(); // Index that previous() would return\n\n // Modification operations\n void remove(); // Remove last returned element\n void set(E e); // Replace last returned element\n void add(E e); // Insert before next element\n}\n```\n\n### ListIterator Cursor Position\n\n```text\nListIterator cursor positions (between elements):\n\n cursor positions: 0 1 2 3 4\n ↓ ↓ ↓ ↓ ↓\n Elements: [ ] → [A] → [B] → [C] → [D] → [ ]\n ↑ ↑ ↑ ↑\n Element indices: 0 1 2 3\n\nAt cursor position 2:\n• previous() returns B (index 1)\n• next() returns C (index 2)\n• previousIndex() returns 1\n• nextIndex() returns 2\n• add(X) inserts X between B and C\n```\n\n### ListIterator Usage Examples\n\n```java\nList list = new ArrayList<>(Arrays.asList(\"A\", \"B\", \"C\", \"D\"));\n\n// Bidirectional traversal\nListIterator it = list.listIterator(2); // Start at position 2\nSystem.out.println(it.next()); // C (moves to position 3)\nSystem.out.println(it.previous()); // C (moves back to position 2)\nSystem.out.println(it.previous()); // B (moves to position 1)\n\n// Replace element\nit = list.listIterator();\nwhile (it.hasNext()) {\n String s = it.next();\n if (s.equals(\"B\")) {\n it.set(\"BB\"); // Replace B with BB\n }\n}\n// list: [A, BB, C, D]\n\n// Insert element\nit = list.listIterator();\nwhile (it.hasNext()) {\n String s = it.next();\n if (s.equals(\"C\")) {\n it.add(\"BC\"); // Insert BC before cursor (after C)\n }\n}\n// list: [A, BB, C, BC, D]\n\n// Reverse iteration\nit = list.listIterator(list.size()); // Start at end\nwhile (it.hasPrevious()) {\n System.out.println(it.previous()); // D, BC, C, BB, A\n}\n```\n\n---\n\n## Deep Dive: Spliterator\n\n`Spliterator` (split-iterator) is designed for parallel traversal:\n\n```java\npublic interface Spliterator {\n // Traversal\n boolean tryAdvance(Consumer action); // Process one element\n void forEachRemaining(Consumer action);\n\n // Splitting\n Spliterator trySplit(); // Divide work for parallelism\n\n // Size estimation\n long estimateSize();\n long getExactSizeIfKnown();\n\n // Characteristics\n int characteristics();\n boolean hasCharacteristics(int characteristics);\n\n // Comparator (for SORTED)\n default Comparator getComparator() {\n throw new IllegalStateException();\n }\n}\n```\n\n### Spliterator Characteristics\n\n```java\npublic interface Spliterator {\n // Characteristic flags\n int ORDERED = 0x00000010; // Encounter order is defined\n int DISTINCT = 0x00000001; // Elements are unique\n int SORTED = 0x00000004; // Elements are sorted\n int SIZED = 0x00000040; // estimateSize() is exact count\n int NONNULL = 0x00000100; // Elements are never null\n int IMMUTABLE = 0x00000400; // Source cannot be modified\n int CONCURRENT = 0x00001000; // Source can be safely modified concurrently\n int SUBSIZED = 0x00004000; // Split spliterators are also SIZED\n}\n```\n\n### Collection Spliterator Characteristics\n\n```java\n// ArrayList: ORDERED | SIZED | SUBSIZED\nList arrayList = new ArrayList<>();\nSpliterator sp1 = arrayList.spliterator();\n// Can split efficiently, knows exact size\n\n// LinkedList: ORDERED | SIZED\nList linkedList = new LinkedList<>();\nSpliterator sp2 = linkedList.spliterator();\n// SIZED but not SUBSIZED - split size estimation is harder\n\n// HashSet: DISTINCT | SIZED\nSet hashSet = new HashSet<>();\nSpliterator sp3 = hashSet.spliterator();\n// Elements unique, unordered\n\n// TreeSet: ORDERED | DISTINCT | SORTED | SIZED\nSet treeSet = new TreeSet<>();\nSpliterator sp4 = treeSet.spliterator();\n// Has all the guarantees\n```\n\n### How trySplit() Works\n\n```java\nList numbers = IntStream.rangeClosed(1, 1000)\n .boxed()\n .collect(Collectors.toList());\n\nSpliterator spliterator = numbers.spliterator();\nSystem.out.println(\"Original size: \" + spliterator.estimateSize()); // 1000\n\n// First split\nSpliterator split1 = spliterator.trySplit();\nSystem.out.println(\"After split 1:\");\nSystem.out.println(\" Original: \" + spliterator.estimateSize()); // 500\nSystem.out.println(\" Split: \" + split1.estimateSize()); // 500\n\n// Second split (on original)\nSpliterator split2 = spliterator.trySplit();\nSystem.out.println(\"After split 2:\");\nSystem.out.println(\" Original: \" + spliterator.estimateSize()); // 250\nSystem.out.println(\" Split 1: \" + split1.estimateSize()); // 500\nSystem.out.println(\" Split 2: \" + split2.estimateSize()); // 250\n```\n\n### ArrayList Spliterator Implementation\n\n```java\n// Simplified from ArrayListSpliterator\nstatic final class ArrayListSpliterator implements Spliterator {\n private final ArrayList list;\n private int index; // Current index, modified on advance/split\n private int fence; // One past last index, -1 until used\n private int expectedModCount;\n\n public Spliterator trySplit() {\n int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;\n return (lo >= mid) ? null : // Too small to split\n new ArrayListSpliterator<>(list, lo, index = mid, expectedModCount);\n }\n\n public boolean tryAdvance(Consumer action) {\n if (action == null) throw new NullPointerException();\n int hi = getFence(), i = index;\n if (i < hi) {\n index = i + 1;\n E e = (E) list.elementData[i];\n action.accept(e);\n if (list.modCount != expectedModCount)\n throw new ConcurrentModificationException();\n return true;\n }\n return false;\n }\n\n public long estimateSize() {\n return (long) (getFence() - index);\n }\n\n public int characteristics() {\n return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;\n }\n}\n```\n\n---\n\n## Deep Dive: Parallel Stream and Spliterator\n\n### When Parallel Streams Help\n\n```java\n// ✅ Good for parallel: CPU-bound, large dataset, independent operations\nList prices = generateMillionPrices();\nBigDecimal total = prices.parallelStream()\n .map(p -> p.multiply(TAX_RATE)) // CPU-bound calculation\n .reduce(BigDecimal.ZERO, BigDecimal::add);\n\n// ❌ Bad for parallel: I/O bound\nList urls = getUrls();\nList contents = urls.parallelStream()\n .map(url -> fetchUrl(url)) // I/O bound - thread starvation!\n .collect(Collectors.toList());\n\n// ❌ Bad for parallel: Small dataset\nList small = Arrays.asList(1, 2, 3, 4, 5);\nint sum = small.parallelStream() // Overhead > benefit\n .mapToInt(i -> i)\n .sum();\n\n// ❌ Bad for parallel: LinkedList\nList linked = new LinkedList<>(numbers);\nlong count = linked.parallelStream() // Poor splittability!\n .filter(n -> n > 50)\n .count();\n```\n\n### Spliterator Quality Impact\n\n```java\n// ArrayList splits evenly - O(1) split\n// Original: [0,1,2,3,4,5,6,7]\n// Split 1: [0,1,2,3] [4,5,6,7]\n// Split 2: [0,1] [2,3] [4,5] [6,7]\n\n// LinkedList splits poorly - O(n) traversal needed\n// Must traverse to find middle point\n// Can't index directly like ArrayList\n```\n\n### Custom Spliterator Example\n\n```java\n// Spliterator for a fixed-size array of primitives\npublic class IntArraySpliterator implements Spliterator.OfInt {\n private final int[] array;\n private int index;\n private final int fence;\n\n public IntArraySpliterator(int[] array, int start, int end) {\n this.array = array;\n this.index = start;\n this.fence = end;\n }\n\n @Override\n public OfInt trySplit() {\n int lo = index, mid = (lo + fence) >>> 1;\n return (lo >= mid) ? null :\n new IntArraySpliterator(array, lo, index = mid);\n }\n\n @Override\n public boolean tryAdvance(IntConsumer action) {\n if (index < fence) {\n action.accept(array[index++]);\n return true;\n }\n return false;\n }\n\n @Override\n public long estimateSize() {\n return fence - index;\n }\n\n @Override\n public int characteristics() {\n return ORDERED | SIZED | SUBSIZED | NONNULL | IMMUTABLE;\n }\n}\n```\n\n---\n\n## Iteration Patterns Comparison\n\n### Pattern 1: Enhanced For-Loop\n\n```java\n// ✅ Best for: Simple read-only traversal\nfor (String item : list) {\n System.out.println(item);\n}\n\n// ⚠️ Cannot modify collection during iteration\n// ⚠️ Cannot access index without counter\n```\n\n### Pattern 2: Iterator\n\n```java\n// ✅ Best for: Removal during iteration\nIterator it = list.iterator();\nwhile (it.hasNext()) {\n String item = it.next();\n if (shouldRemove(item)) {\n it.remove(); // Safe removal\n }\n}\n```\n\n### Pattern 3: ListIterator\n\n```java\n// ✅ Best for: Bidirectional traversal, modification during iteration\nListIterator it = list.listIterator();\nwhile (it.hasNext()) {\n String item = it.next();\n if (shouldReplace(item)) {\n it.set(transform(item)); // Replace in-place\n }\n if (shouldInsertAfter(item)) {\n it.add(newItem); // Insert after current\n }\n}\n```\n\n### Pattern 4: Index-Based Loop\n\n```java\n// ✅ Best for: When you need the index, random access lists\nfor (int i = 0; i < list.size(); i++) {\n String item = list.get(i);\n System.out.println(i + \": \" + item);\n}\n\n// ⚠️ Inefficient for LinkedList - O(n²) total!\n```\n\n### Pattern 5: forEach Method\n\n```java\n// ✅ Best for: Simple operations, functional style\nlist.forEach(System.out::println);\n\n// With index (using AtomicInteger or stream)\nAtomicInteger index = new AtomicInteger();\nlist.forEach(item -> System.out.println(index.getAndIncrement() + \": \" + item));\n```\n\n### Pattern 6: Stream API\n\n```java\n// ✅ Best for: Transformation, filtering, aggregation\nList filtered = list.stream()\n .filter(s -> s.startsWith(\"A\"))\n .map(String::toUpperCase)\n .collect(Collectors.toList());\n\n// ✅ For parallel processing\nlong count = list.parallelStream()\n .filter(this::expensiveCheck)\n .count();\n```\n\n### Pattern 7: removeIf\n\n```java\n// ✅ Best for: Bulk conditional removal\nlist.removeIf(item -> item.isEmpty());\nlist.removeIf(String::isBlank);\n\n// Equivalent to but cleaner than:\nIterator it = list.iterator();\nwhile (it.hasNext()) {\n if (it.next().isEmpty()) {\n it.remove();\n }\n}\n```\n\n### Pattern 8: replaceAll\n\n```java\n// ✅ Best for: Bulk transformation in-place\nlist.replaceAll(String::toUpperCase);\nlist.replaceAll(s -> s.trim());\n\n// Equivalent to but cleaner than:\nListIterator it = list.listIterator();\nwhile (it.hasNext()) {\n it.set(it.next().toUpperCase());\n}\n```\n\n---\n\n## Decision Matrix\n\n```text\n┌─────────────────────────────────────────────────────────────────────────┐\n│ ITERATION PATTERN DECISION TREE │\n├─────────────────────────────────────────────────────────────────────────┤\n│ │\n│ Need to MODIFY collection during iteration? │\n│ ├── Yes, REMOVE elements → Iterator.remove() or removeIf() │\n│ ├── Yes, REPLACE elements → ListIterator.set() or replaceAll() │\n│ ├── Yes, INSERT elements → ListIterator.add() │\n│ └── No modification → Continue below │\n│ │\n│ Need to access INDEX? │\n│ ├── Yes, ArrayList → Index-based loop │\n│ ├── Yes, LinkedList → Use ListIterator with nextIndex() │\n│ └── No → Continue below │\n│ │\n│ Need BIDIRECTIONAL traversal? │\n│ ├── Yes → ListIterator │\n│ └── No → Continue below │\n│ │\n│ Doing TRANSFORMATION/FILTERING? │\n│ ├── Yes, creating new collection → Stream API │\n│ ├── Yes, in-place modification → replaceAll() or removeIf() │\n│ └── No → Continue below │\n│ │\n│ Simple iteration → Enhanced for-loop or forEach() │\n│ │\n└─────────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## ⚠️ Common Mistakes\n\n### Mistake 1: Modifying Collection in Enhanced For-Loop\n\n```java\n// ❌ WRONG: ConcurrentModificationException\nfor (String item : list) {\n if (item.isEmpty()) {\n list.remove(item); // 💥 Boom!\n }\n}\n\n// ✅ CORRECT: Use Iterator.remove()\nIterator it = list.iterator();\nwhile (it.hasNext()) {\n if (it.next().isEmpty()) {\n it.remove();\n }\n}\n\n// ✅ CORRECT: Use removeIf() (cleaner)\nlist.removeIf(String::isEmpty);\n```\n\n### Mistake 2: Calling remove() Without next()\n\n```java\n// ❌ WRONG: IllegalStateException\nIterator it = list.iterator();\nit.remove(); // 💥 No element to remove yet!\n\n// ❌ WRONG: IllegalStateException\nIterator it = list.iterator();\nwhile (it.hasNext()) {\n it.next();\n it.remove();\n it.remove(); // 💥 Can't remove twice!\n}\n\n// ✅ CORRECT: Always call next() before remove()\nIterator it = list.iterator();\nwhile (it.hasNext()) {\n String item = it.next();\n if (shouldRemove(item)) {\n it.remove(); // OK - removes the item from next()\n }\n}\n```\n\n### Mistake 3: Using Index Loop with LinkedList\n\n```java\n// ❌ WRONG: O(n²) performance\nLinkedList linked = new LinkedList<>(data);\nfor (int i = 0; i < linked.size(); i++) {\n process(linked.get(i)); // O(n) for each get!\n}\n\n// ✅ CORRECT: Use iterator - O(n) total\nfor (String item : linked) {\n process(item);\n}\n```\n\n### Mistake 4: Assuming Parallel Stream is Faster\n\n```java\n// ❌ WRONG assumption: parallel is always faster\nList small = Arrays.asList(1, 2, 3, 4, 5);\nint sum = small.parallelStream() // Overhead > benefit!\n .mapToInt(i -> i)\n .sum();\n\n// ❌ WRONG: I/O operations\nurls.parallelStream()\n .map(this::fetchFromNetwork) // Thread starvation!\n .collect(toList());\n\n// ✅ CORRECT: Know when to use parallel\n// - Large datasets (10,000+ elements)\n// - CPU-bound operations\n// - Independent operations\n// - ArrayList (not LinkedList)\n```\n\n### Mistake 5: Not Checking Iterator State\n\n```java\n// ❌ WRONG: NoSuchElementException\nIterator it = list.iterator();\nString first = it.next(); // 💥 Fails if list is empty!\n\n// ✅ CORRECT: Always check hasNext()\nIterator it = list.iterator();\nif (it.hasNext()) {\n String first = it.next();\n}\n\n// ✅ CORRECT: Or use Optional pattern\nOptional first = list.stream().findFirst();\n```\n\n---\n\n## 🐛 Debug This\n\n### Challenge 1: The Silent Skip\n\n```java\nList numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6));\nIterator it = numbers.iterator();\nwhile (it.hasNext()) {\n Integer num = it.next();\n if (num % 2 == 0) {\n numbers.remove(num); // Remove even numbers\n }\n}\nSystem.out.println(numbers); // What prints?\n```\n\n**Question**: What's the output? Why doesn't it throw `ConcurrentModificationException`?\n\n**✅ Answer:**\n\nBehavior is unpredictable! It might print `[1, 3, 5, 6]` or throw `ConcurrentModificationException`.\n\nThe exception is thrown at `it.next()`, not at `numbers.remove()`. If removal happens just before the loop would end naturally, the exception might not be thrown.\n\n**Fix**:\n```java\nnumbers.removeIf(num -> num % 2 == 0);\n// Result: [1, 3, 5]\n```\n\n### Challenge 2: The Double Processing\n\n```java\nList items = new ArrayList<>(Arrays.asList(\"A\", \"B\", \"C\"));\nListIterator it = items.listIterator();\nwhile (it.hasNext()) {\n String item = it.next();\n System.out.print(item + \" \");\n if (item.equals(\"B\")) {\n it.previous();\n it.add(\"X\");\n }\n}\n// What's printed? What's the final list state?\n```\n\n**✅ Answer:**\n\n**Output**: `A B B C`\n\n**Final list**: `[A, X, B, C]`\n\n**Explanation**:\n1. `next()` returns \"A\", prints \"A\"\n2. `next()` returns \"B\", prints \"B\"\n3. `previous()` moves cursor back (returns \"B\" but we ignore it)\n4. `add(\"X\")` inserts X before B, cursor moves after X\n5. `next()` returns \"B\" again (we're still before B), prints \"B\"\n6. `next()` returns \"C\", prints \"C\"\n\n### Challenge 3: The Parallel Puzzle\n\n```java\nList results = Collections.synchronizedList(new ArrayList<>());\nIntStream.range(0, 10000)\n .parallel()\n .forEach(i -> {\n if (i % 2 == 0) {\n results.add(i);\n }\n });\nSystem.out.println(results.size()); // What's the expected output?\n```\n\n**✅ Answer:**\n\nThe output is **unpredictable**, could be any number from ~4500 to 5000.\n\nEven though `synchronizedList` makes individual operations thread-safe, the check-then-act pattern (`i % 2 == 0` then `add`) is not atomic. The `add` operations are safe, but you might get non-deterministic ordering.\n\nActually, in this specific case, since we only do `add`, it should be 5000 (all even numbers from 0 to 9999). But if we had compound operations like check-then-modify, we'd have race conditions.\n\n**Better approach**:\n```java\nList results = IntStream.range(0, 10000)\n .parallel()\n .filter(i -> i % 2 == 0)\n .boxed()\n .collect(Collectors.toList());\n// Guaranteed 5000 elements\n```\n\n---\n\n## 💻 Exercises\n\n### Exercise 1: Implement forEachRemaining\n\nImplement `forEachRemaining` using only `hasNext()` and `next()`:\n\n```java\npublic static void myForEachRemaining(Iterator iterator, Consumer action) {\n // Your implementation here\n}\n```\n\n**✅ Solution:**\n\n```java\npublic static void myForEachRemaining(Iterator iterator, Consumer action) {\n Objects.requireNonNull(action);\n while (iterator.hasNext()) {\n action.accept(iterator.next());\n }\n}\n\n// Usage\nList list = Arrays.asList(\"A\", \"B\", \"C\");\nIterator it = list.iterator();\nit.next(); // Skip first\nmyForEachRemaining(it, System.out::println); // Prints B, C\n```\n\n### Exercise 2: Remove Every Nth Element\n\nWrite a method that removes every Nth element from a list:\n\n```java\npublic static void removeEveryNth(List list, int n) {\n // Your implementation here\n}\n\n// Test\nList nums = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9));\nremoveEveryNth(nums, 3);\n// Result: [1, 2, 4, 5, 7, 8]\n```\n\n**✅ Solution:**\n\n```java\npublic static void removeEveryNth(List list, int n) {\n if (n <= 0) throw new IllegalArgumentException(\"n must be positive\");\n\n Iterator it = list.iterator();\n int count = 0;\n while (it.hasNext()) {\n it.next();\n count++;\n if (count == n) {\n it.remove();\n count = 0;\n }\n }\n}\n\n// Alternative with removeIf and index tracking\npublic static void removeEveryNthAlt(List list, int n) {\n AtomicInteger counter = new AtomicInteger(0);\n list.removeIf(e -> counter.incrementAndGet() % n == 0);\n}\n```\n\n### Exercise 3: Interleave Two Lists\n\nCreate an iterator that interleaves elements from two lists:\n\n```java\npublic class InterleavingIterator implements Iterator {\n // Your implementation here\n}\n\n// Usage\nList a = Arrays.asList(\"A1\", \"A2\", \"A3\");\nList b = Arrays.asList(\"B1\", \"B2\");\nIterator it = new InterleavingIterator<>(a.iterator(), b.iterator());\n// Should yield: A1, B1, A2, B2, A3\n```\n\n**✅ Solution:**\n\n```java\npublic class InterleavingIterator implements Iterator {\n private final Iterator it1;\n private final Iterator it2;\n private boolean useFirst = true;\n\n public InterleavingIterator(Iterator it1, Iterator it2) {\n this.it1 = it1;\n this.it2 = it2;\n }\n\n @Override\n public boolean hasNext() {\n return it1.hasNext() || it2.hasNext();\n }\n\n @Override\n public E next() {\n if (!hasNext()) {\n throw new NoSuchElementException();\n }\n\n // Try to alternate, fall back to whichever has elements\n if (useFirst && it1.hasNext()) {\n useFirst = false;\n return it1.next();\n } else if (!useFirst && it2.hasNext()) {\n useFirst = true;\n return it2.next();\n } else if (it1.hasNext()) {\n return it1.next();\n } else {\n return it2.next();\n }\n }\n}\n```\n\n### Exercise 4: Filtered Iterator\n\nCreate an iterator that only returns elements matching a predicate:\n\n```java\npublic class FilteredIterator implements Iterator {\n // Your implementation here\n}\n\n// Usage\nList nums = Arrays.asList(1, 2, 3, 4, 5, 6);\nIterator evens = new FilteredIterator<>(nums.iterator(), n -> n % 2 == 0);\n// Should yield: 2, 4, 6\n```\n\n**✅ Solution:**\n\n```java\npublic class FilteredIterator implements Iterator {\n private final Iterator source;\n private final Predicate predicate;\n private E nextElement;\n private boolean hasNextElement = false;\n\n public FilteredIterator(Iterator source, Predicate predicate) {\n this.source = source;\n this.predicate = predicate;\n advance();\n }\n\n private void advance() {\n hasNextElement = false;\n while (source.hasNext()) {\n E element = source.next();\n if (predicate.test(element)) {\n nextElement = element;\n hasNextElement = true;\n break;\n }\n }\n }\n\n @Override\n public boolean hasNext() {\n return hasNextElement;\n }\n\n @Override\n public E next() {\n if (!hasNextElement) {\n throw new NoSuchElementException();\n }\n E result = nextElement;\n advance();\n return result;\n }\n}\n```\n\n### Exercise 5: Peekable Iterator\n\nCreate an iterator that allows peeking at the next element without consuming it:\n\n```java\npublic class PeekingIterator implements Iterator {\n public E peek(); // Return next element without advancing\n // Your implementation here\n}\n\n// Usage\nList nums = Arrays.asList(1, 2, 3);\nPeekingIterator it = new PeekingIterator<>(nums.iterator());\nSystem.out.println(it.peek()); // 1\nSystem.out.println(it.peek()); // 1 (still)\nSystem.out.println(it.next()); // 1\nSystem.out.println(it.peek()); // 2\n```\n\n**✅ Solution:**\n\n```java\npublic class PeekingIterator implements Iterator {\n private final Iterator source;\n private E peekedElement;\n private boolean hasPeeked = false;\n\n public PeekingIterator(Iterator source) {\n this.source = source;\n }\n\n public E peek() {\n if (!hasPeeked) {\n if (!source.hasNext()) {\n throw new NoSuchElementException();\n }\n peekedElement = source.next();\n hasPeeked = true;\n }\n return peekedElement;\n }\n\n @Override\n public boolean hasNext() {\n return hasPeeked || source.hasNext();\n }\n\n @Override\n public E next() {\n if (hasPeeked) {\n hasPeeked = false;\n return peekedElement;\n }\n return source.next();\n }\n}\n```\n\n---\n\n## 🎤 Senior-Level Interview Questions\n\n### Question 1: Fail-Fast vs Fail-Safe Iterators\n\n**Q: What's the difference between fail-fast and fail-safe iterators?**\n\n**A:**\n\n**Fail-Fast Iterators** (ArrayList, HashMap, HashSet):\n- Throw `ConcurrentModificationException` if collection is modified during iteration\n- Track `modCount` to detect modifications\n- Provide immediate feedback about concurrent modification\n\n**Fail-Safe Iterators** (CopyOnWriteArrayList, ConcurrentHashMap):\n- Never throw `ConcurrentModificationException`\n- Work on a copy of the collection or use special locking\n- May not reflect modifications made during iteration\n\n```java\n// Fail-fast example\nList list = new ArrayList<>(Arrays.asList(\"A\", \"B\", \"C\"));\nfor (String s : list) {\n list.remove(s); // ConcurrentModificationException!\n}\n\n// Fail-safe example\nList cowList = new CopyOnWriteArrayList<>(Arrays.asList(\"A\", \"B\", \"C\"));\nfor (String s : cowList) {\n cowList.remove(s); // Works! Iterates over snapshot\n}\n```\n\n### Question 2: Iterator.remove() Internals\n\n**Q: Why does `Iterator.remove()` work but `Collection.remove()` throws exception during iteration?**\n\n**A:** The key is `expectedModCount` synchronization:\n\n1. **Collection.remove()**: Increments `modCount` but the iterator's `expectedModCount` stays unchanged. Next `iterator.next()` detects mismatch.\n\n2. **Iterator.remove()**: After removing, it sets `expectedModCount = modCount`, keeping them synchronized.\n\n```java\n// Inside Iterator.remove():\npublic void remove() {\n ArrayList.this.remove(lastRet);\n expectedModCount = modCount; // 🔑 Key line!\n}\n```\n\n### Question 3: Spliterator Characteristics\n\n**Q: What are Spliterator characteristics and why do they matter?**\n\n**A:** Characteristics are bit flags that describe properties of the source collection:\n\n- **SIZED**: Exact count known - enables accurate parallel work division\n- **SUBSIZED**: Split portions also have known sizes\n- **ORDERED**: Encounter order is defined - must be preserved in parallel ops\n- **SORTED**: Elements are sorted - enables optimizations\n- **DISTINCT**: No duplicates - enables certain optimizations\n- **NONNULL**: No null elements - can skip null checks\n- **IMMUTABLE**: Source won't change - safe for parallel access\n- **CONCURRENT**: Can be modified during traversal safely\n\nThese matter for parallel stream optimization - e.g., if not SIZED, parallel division is harder.\n\n### Question 4: Why LinkedList Parallel Streams are Slow\n\n**Q: Why do parallel streams perform poorly with LinkedList?**\n\n**A:** Two main reasons:\n\n1. **Poor Splittability**: LinkedList cannot split in O(1) time. To split, it must traverse to the middle - O(n). ArrayList splits by index calculation - O(1).\n\n2. **No SUBSIZED characteristic**: After splitting, LinkedList doesn't know the exact size of each half without counting, making work distribution uneven.\n\n```java\n// ArrayList: O(1) split\n// Just calculate: mid = (start + end) / 2\n\n// LinkedList: O(n) split\n// Must traverse n/2 nodes to find middle\n```\n\n### Question 5: ListIterator vs Iterator\n\n**Q: When would you use ListIterator instead of Iterator?**\n\n**A:** Use ListIterator when you need:\n\n1. **Bidirectional traversal**: `previous()`, `hasPrevious()`\n2. **Element replacement**: `set(E e)`\n3. **Element insertion**: `add(E e)`\n4. **Index information**: `nextIndex()`, `previousIndex()`\n\n```java\n// Use case: Process and potentially modify elements\nListIterator it = list.listIterator();\nwhile (it.hasNext()) {\n String s = it.next();\n if (s.isEmpty()) {\n it.remove(); // Remove empty\n } else if (s.equals(\"X\")) {\n it.set(\"Y\"); // Replace X with Y\n } else if (needsPrefix(s)) {\n it.previous();\n it.add(\"PREFIX\"); // Insert before current\n it.next(); // Skip past to continue\n }\n}\n```\n\n### Question 6: forEachRemaining vs forEach\n\n**Q: What's the difference between `Iterator.forEachRemaining()` and `Iterable.forEach()`?**\n\n**A:**\n\n**Iterator.forEachRemaining()**:\n- Processes remaining elements in the iterator\n- Iterator position matters - starts from current position\n- Can be used after manually processing some elements\n- One-shot - iterator is exhausted after call\n\n**Iterable.forEach()**:\n- Processes all elements from the beginning\n- Uses internal iteration (collection controls iteration)\n- Can be called multiple times\n- Default implementation creates new iterator each time\n\n```java\nList list = Arrays.asList(\"A\", \"B\", \"C\", \"D\");\n\n// forEach - always starts from beginning\nlist.forEach(System.out::println); // A, B, C, D\nlist.forEach(System.out::println); // A, B, C, D (again)\n\n// forEachRemaining - continues from iterator position\nIterator it = list.iterator();\nit.next(); // Skip A\nit.forEachRemaining(System.out::println); // B, C, D\n// iterator now exhausted\n```\n\n---\n\n## 📝 Summary & Key Takeaways\n\n### Iterator Essentials\n- `Iterator` provides `hasNext()`, `next()`, `remove()`\n- Fail-fast iterators track `modCount` to detect concurrent modification\n- Always use `Iterator.remove()` for safe removal during iteration\n- `forEachRemaining()` processes remaining elements in bulk\n\n### ListIterator Features\n- Bidirectional: `previous()`, `hasPrevious()`\n- Modification: `set()`, `add()`\n- Position: `nextIndex()`, `previousIndex()`\n- Cursor is between elements, not on them\n\n### Spliterator for Parallelism\n- `trySplit()` divides work for parallel processing\n- Characteristics describe source properties\n- SIZED + SUBSIZED = efficient parallel splitting\n- ArrayList splits well, LinkedList doesn't\n\n### Iteration Pattern Selection\n- Enhanced for-loop: Simple read-only traversal\n- Iterator: Need to remove during iteration\n- ListIterator: Need bidirectional or modification\n- removeIf/replaceAll: Bulk conditional operations\n- Stream: Transformation and aggregation\n\n---\n\n## 🏁 Conclusion\n\nIterators are deceptively simple on the surface but reveal sophisticated design when you dig deeper. The fail-fast mechanism protects you from subtle bugs, the ListIterator enables complex traversal patterns, and Spliterator bridges the gap to parallel processing.\n\nKey takeaways:\n1. **Never modify collections during enhanced for-loop** - use Iterator or removeIf\n2. **Understand modCount/expectedModCount** - it's the foundation of fail-fast\n3. **ListIterator cursor is between elements** - add() inserts at cursor position\n4. **Spliterator characteristics matter** - they determine parallel efficiency\n5. **Not all collections parallelize well** - ArrayList yes, LinkedList no\n\nIn the next article, we'll explore Arrays and BitSet - the primitive building blocks that underlie many collection implementations.\n\n---\n\n## 📅 Review Schedule\n\nTo solidify your understanding, review this material:\n- **Tomorrow**: Re-read the Iterator.remove() internals section\n- **In 3 days**: Implement Exercise 4 (FilteredIterator) again without looking\n- **In 1 week**: Explain Spliterator characteristics to a colleague\n- **In 2 weeks**: Review the production story and common mistakes\n\n---\n\n**Next in Series**: [Part 5: Arrays & BitSet - Primitive Foundations](/articles/java-collections-part-5-arrays-and-bitset)\n\n**Series Navigation**: [Part 0: How to Use This Series](/articles/java-collections-part-0-how-to-use-this-series) | [Full Index](/articles/java-collections-compendium)\n","featuredImage","isPublished","isFeatured","subscriptionType","BASIC","publishedAt","2026-06-10T07:19:25.867825Z","createdAt","2026-06-10T07:19:25.868776Z","updatedAt","2026-06-16T21:26:56.086200Z","readingTimeMinutes",22,"estimatedReadingTime","authorId",3,"authorUsername","tomasz_main","categoryName","Java","readingTime","seriesId",5,"seriesOrder",4,"author",{"_31":55,"_100":57,"_101":102,"_103":104,"_105":-5,"_106":-5,"_107":-5,"_108":-5,"_109":-5},"category",{"_31":62,"_73":59,"_35":85,"_76":98,"_99":-5},"tags",[79,80,81,82,83],"series",{"_31":62,"_73":74,"_35":75,"_76":77,"_78":23},"name","Java Collections Compendium: From Fundamentals to Production Mastery","java-collections-compendium","description","A comprehensive 30-part series covering everything about Java Collections Framework. From foundational concepts like generics and equals/hashCode contract, through deep dives into ArrayList, LinkedList, HashMap, TreeMap, ConcurrentHashMap, to modern features like immutable collections, Java 21 sequenced collections, streams & collectors, and production patterns with JPA, Jackson & Spring. Includes real production stories, mental models, exercises, and 50+ interview questions.","isActive",{"_31":95,"_73":96,"_35":97},{"_31":92,"_73":93,"_35":94},{"_31":89,"_73":90,"_35":91},{"_31":86,"_73":87,"_35":88},{"_31":84,"_73":59,"_35":85},14,"java",324,"Iterator","iterator",325,"Iterable","iterable",326,"For-each","for-each",327,"Concurrentmodification","concurrentmodification","Category for Java","colorHex","username","firstName","Tomasz","lastName","Jarosz","profilePicture","bio","website","githubUrl","linkedinUrl"]