23种设计模式之迭代器模式

迭代器模式又称为游标模式，是行为型设计模式之一。 如果要问Java中使用最多的一种模式，答案不是单例模式，也不是工厂模式，更不是策略模式，而是迭代器模式，先来看一段代码吧：

    public static void print(Collection coll){  
        Iterator it = coll.iterator();  
        while(it.hasNext()){  
            String str = (String)it.next();  
            System.out.println(str);  
        }  
    }  

迭代器模式的定义
提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。

迭代器模式的使用场景
遍历一个容器对象时

迭代器模式的UML类图

角色介绍：

• 抽象容器：一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。
• 具体容器：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。
• 抽象迭代器：定义遍历元素所需要的方法，一般来说会有这么三个方法：取得第一个元素的方法first()，取得下一个元素的方法next()，判断是否遍历结束的方法isDone()（或者叫hasNext()），移出当前对象的方法remove(),
• 迭代器实现：实现迭代器接口中定义的方法，完成集合的迭代。

源码实现

//迭代器接口
public interface Iterator<T> {
    /**
     * 是否还有下一个元素
     * @return
     */
    boolean hasNext();

    /**
     * 返回当前位置的元素并将位置移至下一位
     * @return
     */
    T next();
}

//具体迭代器
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> {
    /**
     * 添加一个对象
     * @param obj
     */
    void add(T obj);

    /**
     * 移除一个元素
     * @param obj
     */
    void remove(T obj);

    /**
     * 获取容器的迭代器
     * @return
     */
    Iterator<T> iterator();
}

//具体实现类
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("Aige");
        a.add("Studio\n");
        a.add("SM");
        a.add(" Brother");
        Iterator<String> i = a.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

迭代器模式的优缺点

迭代器模式的优点有：

• 简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
• 可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
• 封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。

迭代器模式的缺点：

对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。

总结：
对于迭代器模式来说，其自身优点很明显也很单一，支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系，而其缺点就是对类文件的增加。对于开发者而言，已经极少会去由自己来实现迭代器了，因此，对于迭代器模式更多的在于了解而非应用。