Iterator, ListIterator and every way to iterate

For this lesson, we'll focus on Iterator, Iterable, ListIterator, every normal way to iterate a List, brief map iteration, Collection.forEach() versus stream().forEach(), sizing an Iterable, Spliterator, legacy Enumeration, and the performance traps interviewers like. This is asked often because the syntax looks easy, but the cursor rules, removal rules and LinkedList.get(i) trap separate API familiarity from real understanding.

01Picture it first: the cursor sits between elements

The easiest way to understand iterator bugs is to stop picturing the cursor on an element. It sits between elements. next() crosses the element on the right, previous() crosses the element on the left, and remove() or set() acts on the last element crossed.

That is why remove() before next() is illegal, and why two removes in a row are illegal. The iterator needs one clear "last returned" element.

Fig. 1

Iterator shows a cursor after A with next and remove behavior, while ListIterator shows a cursor between B and C with next, previous and add at the cursor

Notice the difference. A plain Iterator moves forward. A ListIterator can move both ways because a List has positions, previous elements and insertion points.

02Iterator and Iterable under the hood

Iterable<T> is a tiny contract: it has Iterator<T> iterator(). That one method is enough for enhanced for, forEach, and default spliterator support. A class does not need to be a Collection to be iterable.

import java.util.Iterator;
import java.util.NoSuchElementException;

final class Range implements Iterable<Integer> {
    private final int startInclusive;
    private final int endExclusive;

    Range(int startInclusive, int endExclusive) {
        this.startInclusive = startInclusive;
        this.endExclusive = endExclusive;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<>() {
            private int next = startInclusive;

            @Override
            public boolean hasNext() {
                return next < endExclusive;
            }

            @Override
            public Integer next() {
                if (!hasNext()) throw new NoSuchElementException();
                return next++;
            }
        };
    }
}

Notice three things:

• The Range is reusable because each call to iterator() returns a fresh cursor.
• next() must throw NoSuchElementException after the end. Returning null would be wrong because null can be a valid element in some collections.
• We did not implement remove(), so the default method throws UnsupportedOperationException.

The enhanced for loop over an Iterable compiles roughly to this shape:

for (Iterator<Integer> it = range.iterator(); it.hasNext(); ) {
    Integer n = it.next();
    System.out.println(n);
}

Arrays are the special case: enhanced for over an array compiles to an index loop, not to an Iterator. For everything that implements Iterable, the loop asks for an iterator and uses hasNext() and next().

Removing with Iterator

Iterator.remove() removes the last element returned by next(). It is the safe removal tool because it updates the iterator's own expected modification state. Removing directly from many collections while an iterator is active can trigger ConcurrentModificationException; we cover the details in ConcurrentModificationException explained.

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

List<String> users = new ArrayList<>(List.of("active", "disabled", "active"));

for (Iterator<String> it = users.iterator(); it.hasNext(); ) {
    String status = it.next();
    if (status.equals("disabled")) {
        it.remove();
    }
}

System.out.println(users); // [active, active]