迭代器模式

基本介绍

1. 迭代器模式是常用的设计模式，属于行为型模式
2. 如果集合元素是以不同的方式实现的，当调用者要遍历这些集合元素，就要用到多种遍历方式，而且还会暴露内部结构，这个时候就可以使用迭代器模式进行统一遍历
3. 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不知道集合对象的底层表示，不暴露内部结构

原理

1. Iterator：迭代器接口，jdk提供
2. ConcreteIterator：具体的迭代器类，管理迭代
3. Aggregate：一个统一的聚合集合接口，将调用者和集合解耦
4. ConcreteAggregate：持有对象集合，并提供一个可以返回迭代器的方法

实例

/***
 * @author shaofan
 * @Description 迭代器模式完成学院部门遍历
 */
public class MyIterator {
    public static void main(String[] args) {
        ComputerCollege computerCollege = new ComputerCollege();
        computerCollege.add(new Department("软件工程"));
        computerCollege.add(new Department("计算机科学与技术"));

        InfoCollege infoCollege = new InfoCollege(10);
        infoCollege.add(new Department("信息工程"));

        Output.output(computerCollege);
        System.out.println();
        Output.output(infoCollege);
    }
}

class ComputerCollegeIterator implements Iterator<Department>{
    List<Department> data;
    int position;
    public ComputerCollegeIterator(List<Department> data){
        this.data = data;
        position = 0;
    }

    @Override
    public boolean hasNext() {
        return position<data.size();
    }

    @Override
    public Department next() {
        return data.get(position++);
    }
}

class InfoCollegeIterator implements Iterator<Department>{
    Department[] data;
    int position;
    public InfoCollegeIterator(Department[] data){
        this.data = data;
        position = 0;
    }

    @Override
    public boolean hasNext() {
        return position<data.length;
    }

    @Override
    public Department next() {
        return data[position++];
    }
}

class Department{
    private String name;
    public Department(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    @Override
    public String toString(){
        return this.name;
    }
}

abstract class College{
    abstract Iterator<Department> createIterator();
}

class ComputerCollege extends College{
    private List<Department> data;
    public ComputerCollege(){
        data = new ArrayList<>();
    }
    public void add(Department department){
        data.add(department);
    }

    @Override
    Iterator<Department> createIterator() {
        return new ComputerCollegeIterator(data);
    }
}
class InfoCollege extends College{
    private Department[] data;
    int index = 0;
    public InfoCollege(int size){
        data = new Department[size];
    }

    public void add(Department department){
        data[index++] = department;
    }

    @Override
    Iterator<Department> createIterator() {
        return new InfoCollegeIterator(data);
    }
}

class Output{
    public static void output(College college){
        Iterator<Department> it = college.createIterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

}
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

源码分析

jdk的各个集合，都实现了各自的迭代器
ArrayList

LinkedList

对不同的数据结构，迭代器可以提供统一的遍历方式

总结

优点

1. 提供了一个统一的方法遍历对象那个，客户不用再考虑集合类型
2. 隐藏了集合的内部结构，客户端要遍历集合是只需要取到迭代器，不用知道内部组成
3. 提供了一种设计思想，一个类应该只有一个引起变化的原因，再集合类中吧迭代器分开，就是把管理对象集合和遍历对象集合的责任分开
   缺点
   每个聚合对象都要一个迭代器，会产生多个迭代器类