Java Iterator vs ListIterator Explained — With Real-World Usage Patterns
Every real application eventually needs to walk through a collection of data — a shopping cart, a list of users, a queue of tasks. Java gives you several ways to do this, but Iterator and ListIterator are the tools the language itself uses under the hood. The enhanced for-loop you write every day? That compiles down to an Iterator. Understanding what's really happening gives you control that the for-each loop simply can't provide.
The problem they solve is surprisingly nuanced. You can't safely remove an element from an ArrayList while looping over it with a regular for loop — the indexes shift and you skip elements or get an IndexOutOfBoundsException. You can't traverse a LinkedList backwards without an index (which defeats the point of a linked list). Iterator and ListIterator were designed specifically to solve safe, cursor-based traversal and modification of collections — they give you a protocol, not just a loop.
By the end of this article you'll know exactly when to reach for Iterator instead of for-each, when ListIterator's bidirectional power is worth it, how to safely remove or replace elements mid-traversal, and how to avoid the dreaded ConcurrentModificationException. You'll also have concrete answers for the interview questions that trip up even experienced developers.
What Iterator Actually Is — and Why It Exists
Iterator is an interface in java.util. It defines a contract: any class that implements it promises to let you step through its elements one at a time. The three methods are tiny but powerful: hasNext() tells you if there's another element waiting, next() hands you that element and advances the cursor, and remove() deletes the last element returned by next() from the underlying collection — safely.
The key word there is safely. When you use Iterator.remove(), the iterator and the collection stay in sync. The iterator knows it just removed something and adjusts its internal state accordingly. That's the entire reason Iterator exists — not just to traverse, but to let you traverse and mutate without blowing up.
Every collection in the Java Collections Framework implements the Iterable interface, which has one job: return an Iterator. When you write a for-each loop, the compiler calls iterator() on your collection and calls hasNext() and next() behind the scenes. This means Iterator isn't some advanced feature — it's the beating heart of iteration in Java. Knowing it explicitly just gives you the steering wheel.
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class TaskQueueIterator { public static void main(String[] args) { // A simple task queue — imagine these are pending support tickets List<String> taskQueue = new ArrayList<>(); taskQueue.add("Send welcome email"); taskQueue.add("URGENT: Fix login bug"); taskQueue.add("Update user profile"); taskQueue.add("URGENT: Payment gateway down"); taskQueue.add("Archive old records"); System.out.println("=== Processing Task Queue ==="); // Grab an iterator from the list — the cursor starts BEFORE the first element Iterator<String> taskIterator = taskQueue.iterator(); while (taskIterator.hasNext()) { // hasNext() peeks — doesn't consume String currentTask = taskIterator.next(); // next() consumes and advances cursor System.out.println("Checking: " + currentTask); // Business rule: remove completed urgent tasks from the live queue // Using iterator.remove() — NOT taskQueue.remove() — keeps iterator in sync if (currentTask.startsWith("URGENT")) { System.out.println(" -> Escalating and removing from queue: " + currentTask); taskIterator.remove(); // SAFE removal — no ConcurrentModificationException } } System.out.println("\n=== Remaining Tasks ==="); // For-each is fine here since we're done modifying for (String remainingTask : taskQueue) { System.out.println(" - " + remainingTask); } } }
Checking: Send welcome email
Checking: URGENT: Fix login bug
-> Escalating and removing from queue: URGENT: Fix login bug
Checking: Update user profile
Checking: URGENT: Payment gateway down
-> Escalating and removing from queue: URGENT: Payment gateway down
Checking: Archive old records
=== Remaining Tasks ===
- Send welcome email
- Update user profile
- Archive old records
ListIterator — The Two-Way, Full-Control Iterator
ListIterator extends Iterator and is only available on List implementations (ArrayList, LinkedList, Vector). It adds five critical capabilities that plain Iterator doesn't have: backward traversal with hasPrevious() and previous(), positional awareness with nextIndex() and previousIndex(), element replacement with set(), and element insertion with add().
Think about when you'd actually need this. A text editor's undo/redo history is a perfect example — you need to walk forward through actions to redo them, and backward to undo them. A music playlist that supports both next-track and previous-track is another. Any scenario where you're editing a list in place — replacing certain values based on conditions — becomes dramatically cleaner with ListIterator.set() compared to tracking index variables manually.
The cursor model of ListIterator is worth understanding precisely. The cursor sits BETWEEN elements, not ON them. After calling next(), the cursor has moved past one element — calling previous() returns that same element again. This sounds confusing but it's logically consistent once you visualize the cursor as a gap between elements rather than a pointer to one.
import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class PlaylistManager { public static void main(String[] args) { List<String> playlist = new ArrayList<>(); playlist.add("Intro Track"); playlist.add("Main Theme"); playlist.add("Bridge"); playlist.add("Main Theme"); // duplicate — will be replaced playlist.add("Outro"); System.out.println("=== Original Playlist ==="); playlist.forEach(track -> System.out.println(" " + track)); // Get a ListIterator starting at the BEGINNING (index 0) ListIterator<String> playlistEditor = playlist.listIterator(); System.out.println("\n=== Editing Playlist (Forward Pass) ==="); while (playlistEditor.hasNext()) { // nextIndex() tells us WHERE we are before we consume the element int position = playlistEditor.nextIndex(); String track = playlistEditor.next(); // advance cursor, get element System.out.println("Position " + position + ": " + track); // Replace duplicate 'Main Theme' at position 3 with 'Reprise' if (track.equals("Main Theme") && position == 3) { playlistEditor.set("Main Theme (Reprise)"); // replaces in-place, no index needed System.out.println(" -> Replaced with: Main Theme (Reprise)"); } } System.out.println("\n=== Rewinding (Backward Pass) ==="); // Cursor is now at the END — walk backwards using hasPrevious() while (playlistEditor.hasPrevious()) { int position = playlistEditor.previousIndex(); String track = playlistEditor.previous(); // move cursor back, get element System.out.println("Position " + position + ": " + track); } System.out.println("\n=== Final Playlist ==="); playlist.forEach(track -> System.out.println(" " + track)); } }
Intro Track
Main Theme
Bridge
Main Theme
Outro
=== Editing Playlist (Forward Pass) ===
Position 0: Intro Track
Position 1: Main Theme
Position 2: Bridge
Position 3: Main Theme
-> Replaced with: Main Theme (Reprise)
Position 4: Outro
=== Rewinding (Backward Pass) ===
Position 4: Outro
Position 3: Main Theme (Reprise)
Position 2: Bridge
Position 1: Main Theme
Position 0: Intro Track
=== Final Playlist ===
Intro Track
Main Theme
Bridge
Main Theme (Reprise)
Outro
ConcurrentModificationException — The Most Common Iterator Trap
This exception is the number-one pain point developers hit when they first work with iterators. It occurs when a collection is structurally modified (elements added or removed) through the collection itself while an iterator over it is active. Java's fail-fast iterators detect this using an internal modCount — a counter that increments on every structural change. The iterator captures this count when created, and on every call to next() it checks: 'has this count changed since I was born?' If yes, it throws ConcurrentModificationException immediately.
This is intentional. Java is telling you: 'you're modifying the collection while iterating — your iterator's internal state is now invalid and I'd rather crash loudly than give you silent data corruption.' It's a safety net, not a bug.
The fix is always to route modifications through the iterator itself (iterator.remove(), listIterator.add(), listIterator.set()) or to collect changes and apply them after iteration completes. The latter approach — called 'collect then apply' — is the right choice when you need to add elements, since plain Iterator has no add() method.
import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class SafeCollectionModification { public static void main(String[] args) { List<Integer> temperatures = new ArrayList<>(); temperatures.add(72); temperatures.add(85); temperatures.add(91); // heatwave threshold temperatures.add(68); temperatures.add(95); // heatwave threshold System.out.println("=== BROKEN: This will throw ConcurrentModificationException ==="); try { for (Integer temp : temperatures) { if (temp > 90) { temperatures.remove(temp); // modifying the list WHILE for-each iterates it } } } catch (java.util.ConcurrentModificationException e) { System.out.println("Caught: " + e.getClass().getSimpleName()); System.out.println("Reason: for-each hides an Iterator — we modified the list externally"); } // Reset the data temperatures.clear(); temperatures.add(72); temperatures.add(85); temperatures.add(91); temperatures.add(68); temperatures.add(95); System.out.println("\n=== FIXED: Use iterator.remove() for safe removal ==="); Iterator<Integer> tempIterator = temperatures.iterator(); while (tempIterator.hasNext()) { int reading = tempIterator.next(); if (reading > 90) { System.out.println("Removing heatwave reading: " + reading); tempIterator.remove(); // iterator stays in sync — no exception } } System.out.println("Safe temperatures remaining: " + temperatures); // Adding elements during iteration — Iterator has no add(), so use collect-then-apply System.out.println("\n=== Adding Elements: Collect-Then-Apply Pattern ==="); List<Integer> extraReadings = new ArrayList<>(); Iterator<Integer> scanIterator = temperatures.iterator(); while (scanIterator.hasNext()) { int reading = scanIterator.next(); // Flag each reading that needs a follow-up measurement added after it if (reading < 75) { extraReadings.add(reading - 2); // simulated second sensor reading } } temperatures.addAll(extraReadings); // apply additions AFTER iteration is complete System.out.println("Final temperature list: " + temperatures); } }
Caught: ConcurrentModificationException
Reason: for-each hides an Iterator — we modified the list externally
=== FIXED: Use iterator.remove() for safe removal ===
Removing heatwave reading: 91
Removing heatwave reading: 95
Safe temperatures remaining: [72, 85, 68]
=== Adding Elements: Collect-Then-Apply Pattern ===
Final temperature list: [72, 85, 68, 70, 66]
| Feature / Aspect | Iterator | ListIterator |
|---|---|---|
| Works with | Any Collection (Set, List, Queue) | List only (ArrayList, LinkedList) |
| Direction | Forward only | Forward and backward |
| Methods | hasNext(), next(), remove() | hasNext(), next(), hasPrevious(), previous(), nextIndex(), previousIndex(), add(), set(), remove() |
| Can remove elements | Yes, via remove() | Yes, via remove() |
| Can replace elements | No | Yes, via set() |
| Can add elements | No | Yes, via add() |
| Start position | Always at beginning | Beginning or any index via listIterator(index) |
| Positional awareness | No — blind to index | Yes — nextIndex() and previousIndex() |
| Use case | Safe traversal and removal | Bidirectional traversal, in-place editing, undo/redo patterns |
| Available since | Java 1.2 | Java 1.2 |
🎯 Key Takeaways
- Iterator is the engine under every for-each loop — understanding it explicitly gives you the remove() power that for-each deliberately hides from you.
- ListIterator is Iterator's supercharged sibling: bidirectional traversal, set(), add(), and index awareness — but it only works on Lists, not Sets or Queues.
- ConcurrentModificationException is fail-fast by design — always route structural changes through the iterator (iterator.remove(), listIterator.set()) or use the collect-then-apply pattern for additions.
- The ListIterator cursor sits between elements, not on them — calling next() then previous() returns the same element twice, which is correct behavior and is the foundation of in-place editing patterns.
⚠ Common Mistakes to Avoid
- ✕Mistake 1: Calling list.remove() inside a for-each loop — the for-each loop is syntactic sugar for an Iterator, so modifying the list externally invalidates the iterator's modCount. Symptom: ConcurrentModificationException thrown on the very next iteration. Fix: use iterator.remove() by switching from for-each to an explicit while(iterator.hasNext()) loop.
- ✕Mistake 2: Calling iterator.remove() without calling next() first — Iterator.remove() deletes the element returned by the most recent next() call. If you call remove() before any next() call, or call it twice in a row, it throws IllegalStateException. Fix: always ensure next() has been called exactly once since the last remove() call. The pattern is always: next() first, then remove().
- ✕Mistake 3: Assuming Iterator works on Sets in a predictable order — beginners often use Iterator over a HashSet and expect elements to come out in insertion order. They don't — HashSet makes zero ordering guarantees. Symptom: logic that depends on order silently produces wrong results. Fix: use LinkedHashSet for insertion-order iteration, or TreeSet for sorted order, and document your ordering assumption clearly.
Interview Questions on This Topic
- QWhat is the difference between Iterator and ListIterator in Java, and when would you choose one over the other?
- QWhy does ConcurrentModificationException get thrown when you modify a List during a for-each loop, and what are the two correct ways to handle it?
- QWhat is the difference between Iterator.remove() and List.remove(), and what happens if you call Iterator.remove() before calling Iterator.next()?
Frequently Asked Questions
Can I use Iterator with a Set or Map in Java?
Yes — Iterator works with any class that implements Iterable, including HashSet, TreeSet, and the keySet(), values(), or entrySet() views of a Map. ListIterator, however, is exclusive to List implementations. When iterating a Set, remember there's no guaranteed order unless you use LinkedHashSet or TreeSet.
Is Iterator faster than a for-each loop in Java?
They're the same speed — a for-each loop compiles to Iterator calls. The performance difference comes from the collection type: iterating a LinkedList with a traditional index-based for loop is O(n²) because each get(i) walks the chain, but using an Iterator (or for-each) is O(n) because it follows the internal node pointers. Always prefer Iterator or for-each over index-based loops on LinkedList.
What happens if I call listIterator.set() without calling next() or previous() first?
It throws IllegalStateException. The set() method replaces the element returned by the most recent next() or previous() call. If neither has been called yet — or if add() or remove() was the last structural operation — there's no 'current element' to replace. Always call next() or previous() at least once before calling set() or remove().
Written and reviewed by senior developers with real-world experience across enterprise, startup and open-source projects. Every article on TheCodeForge is written to be clear, accurate and genuinely useful — not just SEO filler.