Safe Removal During Traversal

Removing elements from an ArrayList during a loop seems straightforward — but a naive forward loop skips elements every time it removes one. The result is silent data loss: matches survive when they shouldn't.

The fix is to iterate backwards. By starting at the last index and moving toward the front, each removal only shifts elements that have already been visited.

On the AP exam, safe-removal questions are some of the most common MCQ traps and a recurring FRQ requirement. Master the backward loop and you've defused half the ArrayList exam pitfalls.

The unsafe forward loop

// BUGGY
for (int i = 0; i < list.size(); i++) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
    }
}

Trace this on [0, 0, 1] looking for zeros:

• i=0: list.get(0) is 0 → remove. List becomes [0, 1].
• i=1: list.get(1) is 1 → keep.
• Loop ends. Final: [0, 1]. The second zero survived!

The safe backward loop

for (int i = list.size() - 1; i >= 0; i--) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
    }
}

Trace on the same input [0, 0, 1]:

• i=2: value 1 → keep.
• i=1: value 0 → remove. List becomes [0, 1].
• i=0: value 0 → remove. List becomes [1].

All zeros gone. The backward loop visits each original index exactly once, regardless of how many removals happen.

Why backwards works

When you remove at index i, elements at positions i + 1, i + 2, ... shift left by one. In a backward loop, those positions have already been processed — the shifts touch only the visited region. The unvisited region (lower indices) is untouched.

Forward loop salvage (less clean)

If you must iterate forward, you can avoid the skip by not incrementing after a removal:

int i = 0;
while (i < list.size()) {
    if (shouldRemove(list.get(i))) {
        list.remove(i);
    } else {
        i++;
    }
}

This works but is harder to read. AP-style code prefers the backward loop.