Object Accumulation and Safe Removal

Many AP-style problems require both producing a result and modifying the source. The cleanest approach is the two-phase pattern: read through the source once to accumulate results, then remove items from the source in a separate, safe pass.

Mixing accumulation with removal in a single forward loop leads to the classic skip-elements bug. Separating the phases makes the code easier to reason about and easier for graders to follow.

On the AP exam, this pattern appears when an FRQ asks something like: "Return a list of overdue books, and remove them from the library."

The two-phase template

public ArrayList<SourceType> extractAndRemove(ArrayList<SourceType> source) {
    ArrayList<SourceType> result = new ArrayList<SourceType>();

    // Phase 1: accumulate matches (read-only on source)
    for (SourceType item : source) {
        if (/* condition */) {
            result.add(item);
        }
    }

    // Phase 2: remove matches from source (backwards iteration)
    for (int i = source.size() - 1; i >= 0; i--) {
        if (/* same condition */) {
            source.remove(i);
        }
    }

    return result;
}

Two distinct loops. Phase 1 is read-only on the source — enhanced-for is perfect. Phase 2 is destructive — indexed backwards loop is required.

Concrete example

Assume a Book class with isOverdue(). Extract overdue books into a returned list and remove them from the library:

public ArrayList<Book> checkOutOverdue(ArrayList<Book> library) {
    ArrayList<Book> overdue = new ArrayList<Book>();

    for (Book b : library) {
        if (b.isOverdue()) {
            overdue.add(b);
        }
    }

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

    return overdue;
}

Why two phases?

Mixing them in one forward loop creates the classic bug: each remove(i) shifts later elements left, but i keeps incrementing — so the element that took the removed slot gets skipped.

Two phases sidesteps the problem entirely. Phase 1 reads without modifying. Phase 2 removes safely with a backward index.

Shared references in the result

The returned list holds the same object references that the source originally held. After Phase 2, the source no longer contains those references — but the result list still does, so the objects survive.