设计模式-迭代器模式

设计模式-迭代器模式

迭代器模式（Iterator Design Pattern），也叫作游标模式（Cursor Design Pattern），用来给类实例提供一种遍历对象的方式。

案例分析

首先写一个经典的 User 类

1@Data
2@ToString
3public class User {
4
5    private String uuid;
6
7    private String name;
8
9    private Integer age;
10
11}
12

通常我们遍历一个对象有三种方式

1public class Main {
2    public static void main(String[] args) {
3
4        List<User> userList = IntStream.rangeClosed(1, 10).mapToObj(i -> {
5            User user = new User();
6            user.setUuid(i + "");
7            user.setAge(i);
8            user.setName("name" + i);
9            return user;
10        }).collect(Collectors.toList());
11
12        for (int i = 0; i < userList.size(); i++) {
13            User temp = userList.get(i);
14            System.out.println(temp);
15        }
16
17        for (User temp : userList) {
18            System.out.println(temp);
19        }
20
21        Iterator<User> iterator = userList.iterator();
22        while (iterator.hasNext()) {
23            User temp = iterator.next();
24            System.out.println(temp);
25        }
26
27    }
28}
29

不过如果分析上述这段代码编译出的字节码文件，其实方法二和方法三最终的实现是一样的

1        for (User temp : userList) {
2            System.out.println(temp);
3        }
4
5        Iterator<User> iterator = userList.iterator();
6        while (iterator.hasNext()) {
7            User temp = iterator.next();
8            System.out.println(temp);
9        }
10

实现一个迭代器其实并不复杂，我们可能会好奇一个问题，为什么 userList 可以放在增强 for 循环的位置

1        for (User temp : userList) {
2            System.out.println(temp);
3        }
4

而 User 对象本身不能放在增强 for 循环的位置

1        for (String temp : User) {
2            System.out.println(temp);
3        }
4

结合标题迭代器模式我们很容易想到这个因为 userList 对应的 ArrayList 类实现了迭代器接口

1public interface Iterable<T> {
2    /**
3     * Returns an iterator over elements of type {@code T}.
4     *
5     * @return an Iterator.
6     */
7    Iterator<T> iterator();
8}    
9

所以如果想让 User 类也可以放到增强 for 循环的位置，也需要实现这个接口

1public class User implements Iterable<String>{
2
3    private String uuid;
4
5    private String name;
6
7    private Integer age;
8
9    @Override
10    public Iterator<String> iterator() {
11        return new UserIte();
12    }
13    
14    private class UserIte implements Iterator<String> {
15
16        @Override
17        public boolean hasNext() {
18            return false;
19        }
20
21        @Override
22        public String next() {
23            return null;
24        }
25    }
26    
27}
28

所以实现一个迭代器类只需要两步：

• 类实现 Iterable，代表是可迭代的
• 在类中创建一个内部类实现迭代器接口，实现其中的是否还有下一个元素接口和获取下一个元素接口

由于我们需要记录是否遍历完成，所以 UserIte 中需要使用属性记录当前遍历到的位置

1@Data
2@ToString
3public class User implements Iterable<String> {
4
5    private String uuid;
6
7    private String name;
8
9    private Integer age;
10
11    @Override
12    public Iterator<String> iterator() {
13        return new UserIte();
14    }
15
16    private class UserIte implements Iterator<String> {
17
18        private Integer index;
19
20        private List<String> propertyList = new ArrayList<>();
21
22        public UserIte() {
23            index = 0;
24            propertyList.add(User.this.uuid);
25            propertyList.add(User.this.name);
26            propertyList.add(User.this.age + "");
27        }
28
29        @Override
30        public boolean hasNext() {
31            return index < propertyList.size();
32        }
33
34        @Override
35        public String next() {
36            if (index >= propertyList.size()) {
37                throw new NoSuchElementException("没有" + index + "对应的元素");
38            }
39            return propertyList.get(index++);
40        }
41    }
42
43}
44

这样就可以对 User 的对象进行遍历了

1public class Main {
2    public static void main(String[] args) {
3        List<User> userList = IntStream.rangeClosed(1, 10).mapToObj(i -> {
4            User user = new User();
5            user.setUuid(i + "");
6            user.setAge(i);
7            user.setName("name" + i);
8            return user;
9        }).collect(Collectors.toList());
10
11        User temp = userList.get(0);
12        for (String s : temp) {
13            System.out.println(s);
14        }
15    }
16}
17

实现一个迭代器并不是很复杂，但是如果你仔细看上面的实现就会有疑问，如果在遍历的过程中对元素进行了变化，那么迭代过程中会出现什么问题呢？

这里不再演示之间说结论，有可能出错也有可能不出错，迭代器中有一个 cursor 的概念，Mysql 中其实也有这个游标的概念。

如上图所示：当游标指向 b 的时候，删除了数组中的 a 元素，由于数组会进行补齐，所以 cursor 会指向 d，元素 c 就会错过遍历。如果指向最后一个元素的时候被删了，那么可能会出现空指针。事实上，在计算机中，不可预知的结果（出错或不出错）比出错更让人头疼，因此最好的处理方式就是只要出现了预期之外的操作就报错，让开发人员尽快处理这样的操作。

如果你查看 ArrayList 的实现，会发现其在每次进行 add 或 remove 操作的时候，会对其中的 modCount 进行 +1，记录出现的更新次数，并在创建迭代器时将该次数传入，并在每次进行遍历时先判断迭代器中修改次数的和实例的修改次数是否相同，如果不同就抛出异常。

总结

所以，实现一个迭代器模式并不复杂，但是迭代器存在的意义是什么呢？为什么不都用 for i 类型的遍历呢？

对于复杂的数据结构（比如树、图）来说，有各种复杂的遍历方式。比如，树有前中后序、按层遍历，图有深度优先、广度优先遍历等等。如果由客户端代码来实现这些遍历算法，势必增加开发成本，而且容易写错。如果将这部分遍历的逻辑写到容器类中，也会导致容器类代码的复杂性。

前面也多次提到，应对复杂性的方法就是拆分。我们可以将遍历操作拆分到迭代器类中。比如，针对图的遍历，我们就可以定义 DFSIterator、BFSIterator 两个迭代器类，让它们分别来实现深度优先遍历和广度优先遍历。

其次，将游标指向的当前位置等信息，存储在迭代器类中，每个迭代器独享游标信息。这样，我们就可以创建多个不同的迭代器，同时对同一个容器进行遍历而互不影响。而且迭代器之间都实现了迭代器接口，可以利用多态特性很方便的互相替换，例如从前遍历转为从后遍历，体现了面向接口编程的思想。

《设计模式-迭代器模式》 是转载文章，点击查看原文。