设计模式之迭代器模式

迭代器模式(Iterator Pattern),提供一种方法顺序访问一个聚合对象中的各个元素,而又不暴露该对象的内部表示,属于行为型模式。

大部分高级语言本身就已经实现了迭代器模式,如 Java 中的 foreach 会被编译器处理为 Iterator。

组成

迭代器模式由抽象迭代类 Iterator 、具体迭代类 ConcreteIterator 、抽象聚合类 Aggregate 和具体聚合类 ConcreteAggregate 组成。

其中 Iterator 定义获取下一个对象、判断是否到尾部等接口;ConcreteIterator 为 Iterator 的具体实现;Aggregate 包含一个获取 Iterator 的接口;ConcreteAggregate 实现 Aggregate 接口,包含获取 Iterator 的具体逻辑。

优点

存储和遍历数据的职责分离,迭代器简化了聚合类。

支持以不同的方式遍历一个聚合对象。

方便增加新的聚合类和迭代器类,无须修改原有代码。

缺点

存储和遍历数据的职责分离,增加新的聚合类需要对应增加新的迭代器类,类的个数成对增加,一定程度上增加了系统的复杂性。

使用场景

需要遍历聚合对象的内容而无须关注内部表示,需要为聚合对象提供多种遍历方式,或需要为不同聚合结构提供一个统一接口时,可以使用迭代器模式。

设计原则

遵循单一职责原则、开闭原则和最小知识原则(迪米特法则)。

示例代码

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
public interface Iterator<T> {
T next();
boolean hasNext();
}

public interface Aggregate<T> {
Iterator<T> createIterator(boolean asc);
void add(T t);
void remove(T t);
T get(int index);
int size();
}

public class ConcreteIteratorAsc<T> implements Iterator<T> {

private ConcreteAggregate<T> aggregate;

public ConcreteIteratorAsc(ConcreteAggregate<T> aggregate) {
this.aggregate = aggregate;
}

private int currentIndex = 0;

@Override
public T next() {
return aggregate.get(currentIndex++);
}

@Override
public boolean hasNext() {
return currentIndex < aggregate.size();
}
}

public class ConcreteIteratorDesc<T> implements Iterator<T> {

private ConcreteAggregate<T> aggregate;
private int currentIndex;

public ConcreteIteratorDesc(ConcreteAggregate<T> aggregate) {
this.aggregate = aggregate;
this.currentIndex = aggregate.size() - 1;
}

@Override
public T next() {
return aggregate.get(currentIndex--);
}

@Override
public boolean hasNext() {
return currentIndex >= 0;
}
}

public class ConcreteAggregate<T> implements Aggregate<T> {

private List<T> list = new ArrayList<>();

@Override
public Iterator<T> createIterator(boolean asc) {
return asc ? new ConcreteIteratorAsc<>(this) : new ConcreteIteratorDesc<>(this);
}

@Override
public void add(T t) {
list.add(t);
}

@Override
public void remove(T t) {
list.remove(t);
}

@Override
public T get(int index) {
return list.get(index);
}

@Override
public int size() {
return list.size();
}
}

public class Client {
public static void main(String[] args) {
Aggregate<Integer> aggregate = new ConcreteAggregate<>();
aggregate.add(1);
aggregate.add(2);
aggregate.add(3);
aggregate.add(4);

Iterator<Integer> iterator1 = aggregate.createIterator(true);
while (iterator1.hasNext()) {
System.out.println(iterator1.next());
}

Iterator<Integer> iterator2 = aggregate.createIterator(false);
while (iterator2.hasNext()) {
System.out.println(iterator2.next());
}
}
}
打赏
  • 版权声明: 本博客所有文章除特别声明外,著作权归作者所有。转载请注明出处!
  • © 2016-2020 姜越

谢谢老板

支付宝
微信