迭代器模式

概念

在遍历容器对象的场景下，在客户类与容器之间插入一个迭代器，实现顺序访问容器中的各个元素，同时又不暴露该容器对象的内部表示。

实现方式

public interface Iterator<T> {
    boolean hasNext();
    T next();
}

public class ConcreteIterator<T> implements Iterator<T> {
    public List<T> list = new ArrayList<T>();
    private cursor = 0;

    public ConcreteIterator(List<T> l){
        this.list = l;
    }

    @Override
    public boolean hasNext(){
        return cursor != list.size();
    }

    @Override
    public T next(){
        T obj = null;
        if(this.hasNext()){
            obj = this.list.get(cursor++);
        }
        return obj;
    }
}

/*容器接口*/
public interface Aggregate<T> {
    void add(T obj);
    void remove(T obj);
    Iterator<T> iterator();
}

public class MyList<T> implements Aggregate<T> {
    private List<T> list = new ArrayList<T>();

    @Override
    public void add(T obj){
        list.add(obj);
    }

    @Override
    public void remove(T obj){
        list.remove(obj);
    }

    @Override
    public Iterator<T> iterator(){
        return new ConcreteIterator<T>(list);
    }    
}

public class Test{
    public static void main(String[] args){
        Aggregate<String> a = new MyList<String>();
        a.add("1");
        a.add("2");
        a.add("3");
        Iterator<String> i = a.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }
    }
}