迭代器模式简介及使用示例

迭代器模式简介

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

java中各类集合都已经封装了迭代器的相关设计，实际开发中很少会需要自行开发迭代器，所以学习价值大于实用价值。
迭代器模式通过把聚合对象的访问独立分离出来，使用者不必关心聚合对象内部结构即可进行访问（主要是各种遍历）。

类图：

使用示例

public abstract class Iterator<T> {
    protected Aggregate<T> aggregate;
    public Iterator(Aggregate<T> aggregate) {
        this.aggregate = aggregate;
    }

    public abstract boolean hasNext();
    public abstract T next();
    public abstract T first();
    public abstract int current();
}

public class ConcreteIterator<T> extends Iterator<T> {
    private int current = -1;
    public ConcreteIterator(Aggregate<T> aggregate) {
        super(aggregate);
    }

    @Override
    public boolean hasNext() {
        return current < super.aggregate.size()-1;
    }

    @Override
    public T next() {
        if(hasNext()){
            return super.aggregate.get(++current);
        }else {
            return null;
        }
    }

    @Override
    public T first() {
        return super.aggregate.get(0);
    }

    @Override
    public int current() {
        return this.current;
    }
}

public abstract class Aggregate<T> {
    public abstract Iterator<T> getIterator();
    public abstract void add(T item);
    public abstract int size();
    public abstract T get(int i);
}

public class ConcreteAggregate<T> extends Aggregate<T> {
    @Override
    public Iterator<T> getIterator() {
        return new ConcreteIterator<>(this);
    }
    private List<T> itemList = new ArrayList<>();
    public void add(T item){
        itemList.add(item);
    }
    public int size(){
        return itemList.size();
    }

    @Override
    public T get(int i) {
        return itemList.get(i);
    }
}

public class Client {
    public static void main(String[] args) {
        Aggregate<String> concreteAggregate = new ConcreteAggregate<>();

        concreteAggregate.add("张三");
        concreteAggregate.add("李四");
        concreteAggregate.add("王五");
        concreteAggregate.add("赵六");

        Iterator<String> iterator = concreteAggregate.getIterator();
        for(String item = iterator.next();
            iterator.hasNext();
            item = iterator.next()){
            System.out.println(iterator.current());
            System.out.println(item);
        }
    }
}

结果输出：

0
张三
1
李四
2
王五

总结

优缺点

优点：分离了集合对象的遍历行为，抽象出一个迭代器类来负责，在不暴露集合内部结构的情况下让外部代码访问集合数据。
缺点：会产生多余的类。

使用场景

当需要对聚集进行多种方式的遍历，可以考虑使用迭代器模式。

扩展联想学习

其他设计模式