Iterator vs ListIterator in Java

Iterator is the general-purpose interface. It has exactly three methods — hasNext, next and remove — and it gives you forward-only traversal over any Collection. The remove method deletes the element the iterator last returned, and it is the only way to remove during traversal without triggering the fail-fast check.

ListIterator extends Iterator and is obtained from a List rather than from the Collection interface. It adds four things. It allows bidirectional traversal, with previous and hasPrevious. It exposes the index of the current position, through nextIndex and previousIndex. It adds a set method that replaces the element the iterator last returned. And it adds an add method that inserts a new element at the current position.

That gives ListIterator a genuinely useful property: it can insert into the list at the cursor without shifting the remaining elements the way the List's own add(int, E) would. For an ArrayList, inserting through the iterator is O(n) because the array still has to shift, but for a LinkedList it is O(1), because the node is simply relinked.

One subtlety worth knowing. The remove and set methods may only be called after a next or previous call, because they act on the element the iterator last returned. Calling them first throws IllegalStateException.

And a reminder about the fail-fast behaviour: both iterators detect concurrent modification and throw ConcurrentModificationException, but only if the collection supports it. The iterator of a ConcurrentHashMap, for instance, is weakly consistent and never throws.

A ListIterator lets you replace the current element with set, remove it with remove, and insert a new one before it with add. All three act at the cursor and all three keep the iterator's view of the list consistent, so you never trigger the fail-fast check.

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Grace", "Alan", "Katherine"));

        ListIterator<String> it = names.listIterator();
        while (it.hasNext()) {
            String name = it.next();
            if (name.startsWith("A")) {
                it.set(name.toUpperCase());   // replace the current element
            }
            if (name.startsWith("K")) {
                it.remove();                  // remove the current element
            }
        }
        System.out.println("after edit : " + names);

        // A ListIterator can also insert.
        ListIterator<String> forward = names.listIterator();
        while (forward.hasNext()) {
            forward.next();
            if (forward.nextIndex() == 1) {
                forward.add("INSERTED");
                break;
            }
        }
        System.out.println("after add  : " + names);
    }
}

The output shows the three operations. The first pass upper-cased the two names beginning with A and removed Katherine, leaving three elements. The second pass inserted INSERTED at position one, immediately after the first element, because add puts the new value before the cursor's current position once the cursor has moved past it.

Two alternatives worth mentioning in an interview. The removeIf method is the modern idiom for removing elements by predicate — it is clearer and it does the right thing internally. And the replaceAll method does the same job as calling set on every element. But when you need to insert while iterating, or traverse backwards, the ListIterator is still the tool, and it is the one that answers the question "what is the difference between Iterator and ListIterator" concretely.