Iterator Pattern Explained: Real‑World Scenarios and Java Code

What is the Iterator Pattern?

In plain terms, the Iterator pattern extracts collection‑traversal logic into an independent iterator that exposes only two operations to the client: retrieving the next element and checking whether another element exists. Users do not need to know whether the underlying collection is an array, a linked list, or a tree.

The core purpose is to decouple storage from traversal, providing a uniform traversal interface that works with many kinds of containers.

Real‑World Scenarios

Package pickup codes: whether a parcel is on a shelf or in a locker, it can be taken out sequentially.

Software: JDK’s built‑in Iterator traverses List/Set, and custom tree‑menu iterators traverse hierarchical structures.

Pagination data, database result sets, and heterogeneous data sources can all be wrapped for uniform iteration.

Java Code Implementation (Custom Goods Collection)

1. Unified Iterator Interface

public interface Iterator {
    boolean hasNext();
    Object next();
}

2. Goods Entity

public class Goods {
    private String name;
    public Goods(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
}

3. Aggregate Interface

public interface GoodsAggregate {
    Iterator getIterator();
}

4. Concrete Aggregate (GoodsList)

public class GoodsList implements GoodsAggregate{
    private Goods[] goodsArr;
    private int index = 0;

    public GoodsList(int size){
        goodsArr = new Goods[size];
    }
    // Add a product
    public void add(Goods goods){
        goodsArr[index++] = goods;
    }
    @Override
    public Iterator getIterator() {
        return new GoodsIterator(goodsArr);
    }
}

5. Custom Iterator (GoodsIterator)

public class GoodsIterator implements Iterator{
    private Goods[] arr;
    private int pos = 0;

    public GoodsIterator(Goods[] arr){
        this.arr = arr;
    }
    @Override
    public boolean hasNext() {
        return pos < arr.length && arr[pos] != null;
    }
    @Override
    public Object next() {
        return arr[pos++];
    }
}

6. Test Traversal

public class Test {
    public static void main(String[] args) {
        GoodsList list = new GoodsList(3);
        list.add(new Goods("T恤"));
        list.add(new Goods("裤子"));
        list.add(new Goods("鞋子"));

        Iterator it = list.getIterator();
        while(it.hasNext()){
            Goods g = (Goods) it.next();
            System.out.println(g.getName());
        }
    }
}

Common Business Scenarios for the Iterator Pattern

Need to traverse multiple collections with different underlying structures (arrays, linked lists, trees) using a single interface.

JDK collection framework: List, Set, Map all provide built‑in iterators.

Uniform traversal of database query result sets and paginated lists.

Recursive iteration tools for tree menus and multi‑level categories.

Unified looping over merged heterogeneous data sources.

Pros and Cons

Advantages: Decouples collection from traversal; adding a new container only requires a matching iterator.

Disadvantages: For simple collections the extra iterator class adds code overhead.

Conclusion and Next Topic

The 16th episode on the Iterator pattern is complete. The next update will cover the Mediator pattern, keeping the series on track.