设计模式之迭代器模式

迭代器模式源于对容器的访问，比如java中的List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对容器类来说就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外提供遍历的接口方法，如果我们不提供遍历方法而让使用者自己去实现，又会让容器的内部细节暴露无遗，正因于此，迭代器模式应运而生，在客户访问类与容器之间插入一个第三者——迭代器，很好地解决上面地弊端。

//迭代器接口类：负责定义、访问和遍历元素的接口
public interface Iterator<T> {

    //是否有下一个元素
    boolean hasNext();
    //返回当前位置的元素并将位置移至下一位
    T next();
}

import java.util.ArrayList;
import java.util.List;

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

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

    @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();
}

import java.util.ArrayList;
import java.util.List;

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

    @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<>(list);
    }
}

public class Client {
    public static void main(String[] args) {
        Aggregate<String> a = new ConcreteAggregate<>();
        a.add("AAA");
        a.add("BBB");
        a.add("CCC");
        a.add("DDD");
        Iterator<String> i = a.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

对于迭代器模式来说，其自身有点很明显也很单一，支持以不同的方式去遍历一个容器对象，弱化了容器类与遍历算法之间的关系，其缺点就是对类文件的增加。几乎每一种高级语言的容器都有相应的内置迭代器的实现，对于开发者来说，已经极少会去自己来实现迭代器了，因此，对于迭代器模式我们更多地是了解即可。