大话设计模式——24.迭代器模式（Iterator Pattern）

简介

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部实现。（Java中使用最多的设计模式之一）

UML图

应用场景

• Java的集合对象：Collection、List、Map、Set等都有迭代器
• Java ArrayList的迭代器源码
  

示例

简单实现集合中的迭代器功能

1. Iterator:

public interface Iterator {


    /**
     * 是否有下个元素
     *
     * @return
     */
    boolean hasNext();

    /**
     * 当前元素
     *
     * @return
     */
    Object next();

    /**
     * 删除元素
     *
     * @param obj
     */
    void remove(Object obj);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class ListIterator implements Iterator {


    private List list;

    /**
     * 索引
     */
    private int index = 0;

    public ListIterator(List list) {
        this.list = list;
    }

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

    @Override
    public Object next() {
        Object obj = null;
        if (hasNext()) {
            obj = list.get(index);
            index++;
        }
        return obj;
    }

    @Override
    public void remove(Object obj) {
        list.remove(obj);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

2. Aggregate:

public interface ICollection {

    /**
     * 添加元素
     *
     * @param obj
     */
    void add(Object obj);

    /**
     * 删除元素
     *
     * @param obj
     */
    void remove(Object obj);

    /**
     * 迭代元素
     *
     * @return
     */
    Iterator iterator();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ListCollection implements ICollection {

    private List list = new ArrayList();

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

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

    @Override
    public Iterator iterator() {
        return new ListIterator(list);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.运行

public class Main {

    public static void main(String[] args) {
        ListCollection listCollection = new ListCollection();
        listCollection.add("aaaaaa");
        listCollection.add("bbbbbb");
        listCollection.add("cccccc");
        listCollection.add("dddddd");

        // 创建迭代器
        Iterator iterator = listCollection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

总结

• 优点

  • 可以不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据
  • 支持以不同的方式遍历一个聚合对象

• 缺点

  • 对于比较简单的遍历如数组、有序列表，该方式实现比较繁琐
  • 在遍历的同时更改迭代器所在的集合结构会导致异常