设计模式
迭代器模式
集合是编程中最常使用的数据类型之一， 尽管如此， 集合只是一组对象的容器而已。大部分集合使用简单列表存储元素。但有些集合还会使用栈、 树、 图和其他复杂的数据结构。无论集合的构成方式如何， 它都必须提供某种访问元素的方式， 便于其他代码使用其中的元素。 集合应提供一种能够遍历元素的方式， 且保证它不会周而复始地访问同一个元素。如果你的集合基于列表， 那么这项工作听上去仿佛很简单。 但如何遍历复杂数据结构 （例如树） 中的元素呢？ 例如， 今天你需要使用深度优先算法来遍历树结构， 明天可能会需要广度优先算法； 下周则可能会需要其他方式 （比如随机存取树中的元素）。
不断向集合中添加遍历算法会模糊其 “高效存储数据” 的主要职责。 此外，有些算法可能是根据特定应用订制的， 将其加入泛型集合类中会显得非常奇怪。另一方面，使用多种集合的客户端代码可能并不关心存储数据的方式。 不过由于集合提供不同的元素访问方式，你的代码将不得不与特定集合类进行耦合。
迭代器模式能够较好的解决以上问题，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足 “单一职责原则” 和 “开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器，我们可以通过 iterator() 方法获取他。
迭代器模式在现实生活中应用也有很多，比如：快递物流中的商品，快递员不需要关心配送的商品具体是什么，通过上面的地址，一个一个发送的目的地即可。再比如，我们平时上班乘坐公交车/地铁，都是统一刷卡/扫描进站，而不需要关心乘客的具体信息。
模式的定义
送代器模式（Iterator），提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。它是一种对象行为模式。
模式的优点：
- 将遍历聚合对象中数据的行为提取出来，封装到一个迭代器中，通过专门的迭代器来遍历聚合对象的内部数据，这就是迭代器模式的本质。迭代器模式是 “单一职责原则” 的完美体现。
- 它支持以不同方式遍历一个聚合，可以自定义迭代器的子类以支持新的遍历。
- 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点：
- 增加了类的个数，会在一定程度上增加程序的复杂性。
模式的结构
聚合：多个对象聚在一起形成的总体称之为聚合（Aggregate），聚合对象是能够包容一组对象的容器对象。聚合依赖于聚合结构的抽象化，具有复杂化和多样性。数组就是最基本的聚合，也是其他的 JAVA 聚合对象的设计基础。
迭代器模式的主要角色如下：
- 抽象聚合角色（Aggregate）：定义了创建迭代器对象的接口。
- 具体聚合角色（Concrete Aggregate）：实现抽象聚合类，返回一个具体迭代器的实例。
- 抽象迭代器角色（Iterator）：定义访问和遍历聚合元素的接口，如：
first、next、hasNext、currentItem等方法。 - 具体迭代器角色（Concrete Iterator）：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
模式的 UML 类图如下：
模式的使用
迭代器模式有两种实现方式，分别是：白箱聚合与外禀迭代器 和 黑箱聚合与内禀迭代器
模式一、白箱聚合与外禀迭代器
宽接口：如果一个聚合的接口为外部提供了可以用来访问聚合元素的方法，这个接口就是所谓的宽接口。
白箱聚合：聚合对象对外部提供访问聚合元素的方法【即宽接口】，那这个对象就是白箱聚合对象。
/**
* 抽象聚合类
*/
public interface WhiteAggregate {
/**
* 获取迭代器
* @return
*/
WhiteIterator getIterator();
}
/**
* 具体聚合类
*/
public class WhiteConcreteAggregate implements WhiteAggregate {
private Object[] array = null;
public WhiteConcreteAggregate(Object[] array) {
this.array = array;
}
/**
* 向外界提供聚合元素
*/
public Object getElement(int index) {
if (index < array.length) {
return array[index];
} else {
return null;
}
}
/**
* 向外界提供聚合元素的修改方法
* @param index
* @param value
* @return
*/
public boolean update(int index, Object value) {
if (index < array.length) {
array[index] = value;
return true;
} else {
return false;
}
}
/**
* 向外界提供聚合大小
*/
public int size() {
return array.length;
}
@Override
public WhiteIterator getIterator() {
return new WhiteConcreteIterator(this);
}
}
/**
* 抽象迭代器
*/
public interface WhiteIterator {
/**
* 移动到第一个元素
*/
void first();
/**
* 移动到下一个元素
*/
void next();
/**
* 是否存在下一个元素
* @return
*/
boolean hasNext();
/**
* 获取当前元素
* @return
*/
Object currentItem();
}
/**
* 具体迭代器 - 白箱
*/
public class WhiteConcreteIterator implements WhiteIterator {
/**
* 具体聚合对象
*/
private WhiteConcreteAggregate concreteAggregate;
/**
* 记录迭代器位置的索引
*/
private int index;
/**
* 聚合对象的大小
*/
private int size;
public WhiteConcreteIterator(WhiteConcreteAggregate concreteAggregate) {
this.concreteAggregate = concreteAggregate;
this.size = concreteAggregate.size();
this.index = 0;
}
@Override
public void first() {
index = 0;
}
@Override
public void next() {
if (index < size) {
index ++;
}
}
@Override
public boolean hasNext() {
return (index < size);
}
@Override
public Object currentItem() {
return concreteAggregate.getElement(index);
}
}
/**
* 迭代器模式测试
*/
public class WhiteteratorTest {
public static void main(String[] args) {
String[] array = {"One","Two","Three","Four","Five","Six"};
WhiteAggregate aggregate = new WhiteConcreteAggregate(array);
WhiteIterator iterator = aggregate.getIterator();
while (iterator.hasNext()) {
System.out.println(iterator.currentItem());
iterator.next();
}
}
}
运行程序，结果如下：
模式二、黑箱聚合迭代器
窄接口：如果一个聚合的接口没有向外界提供获访问聚合元素的方法，这样的接口就是所谓的窄接口。
黑箱聚合：聚合对象不对外部提供访问聚合元素的方法【即窄接口】，那这个对象就是黑箱聚合对象。
/**
* 抽象聚合类
*/
public interface BlackAggregate {
/**
* 获取迭代器
* @return
*/
BlackIterator getIterator();
}
/**
* 抽象迭代器
*/
public interface BlackIterator {
/**
* 移动到第一个元素
*/
void first();
/**
* 移动到下一个元素
*/
void next();
/**
* 是否存在下一个元素
* @return
*/
boolean hasNext();
/**
* 获取当前元素
* @return
*/
Object currentItem();
}
/**
* 具体聚合类 - 黑箱聚合【内含一个具体迭代器】
*/
public class BlackConcreteAggregate implements BlackAggregate {
private Object[] array = null;
public BlackConcreteAggregate(Object[] array) {
this.array = array;
}
@Override
public BlackIterator getIterator() {
return new ConcreteIterator();
}
/**
* 内部成员类，具体迭代子类
*/
private class ConcreteIterator implements BlackIterator {
/**
* 记录迭代器位置的索引
*/
private int index;
/**
* 聚合对象的大小
*/
private int size;
public ConcreteIterator() {
this.size = array.length;
this.index = 0;
}
@Override
public void first() {
index = 0;
}
@Override
public void next() {
if (index < size) {
index ++;
}
}
@Override
public boolean hasNext() {
return (index < size);
}
@Override
public Object currentItem() {
return array[index];
}
}
}
/**
* 迭代器模式测试
*/
public class BlackIteratorTest {
public static void main(String[] args) {
String[] array = {"AA", "BB", "CC", "DD", "EE", "FF", "GG"};
BlackAggregate aggregate = new BlackConcreteAggregate(array);
BlackIterator iterator = aggregate.getIterator();
while (iterator.hasNext()) {
System.out.println(iterator.currentItem());
iterator.next();
}
}
}
运行程序，结果如下：
模式的应用场景
大多数语言在实现聚合类时都提供了迭代器类，因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。
迭代器的具体应用场景如下：
- 当你需要对聚合有多种方式遍历时，可以考虑用迭代器模式。
- 当你需要访问一个聚合对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。
- 当聚合背后为复杂的数据结构，且你希望对客户端隐藏其复杂性时（出于使用便利性或安全性的考虑），可以使用迭代器模式。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
