迭代器模式
1）概述
1.概念
存储多个成员对象（元素）的类叫聚合类(Aggregate Classes)，对应的对象称为聚合对象。
聚合对象有两个职责，一是存储数据，二是遍历数据。
2.概述
迭代器模式(Iterator Pattern) 提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。
3.作用
更加方便地操作聚合对象，可以灵活地为聚合对象增加不同的遍历方法。
可以访问一个聚合对象中的元素但又不需要暴露它的内部结构。
4.迭代器模式+工厂方法模式结构图
5.角色
Iterator（抽象迭代器）：定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法。
ConcreteIterator（具体迭代器）：实现了抽象迭代器接口，完成对聚合对象的遍历，在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，游标通常是一个表示位置的非负整数。
Aggregate（抽象聚合类）：用于存储和管理元素对象，声明createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
ConcreteAggregate（具体聚合类）：实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。
6.代码实现
抽象迭代器
interface Iterator {
//将游标指向第一个元素
public void first();
//将游标指向下一个元素
public void next();
//判断是否存在下一个元素
public boolean hasNext();
//获取游标指向的当前元素
public Object currentItem();
}
具体迭代器
public class ConcreteIterator implements Iterator {
//维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
private ConcreteAggregate objects;
//定义一个游标，用于记录当前访问位置
private int cursor;
public ConcreteIterator(ConcreteAggregate objects) {
this.objects=objects;
}
public void first() { ...... }
public void next() { ...... }
public boolean hasNext() { ...... }
public Object currentItem() { ...... }
}
抽象聚合类
interface Aggregate {
Iterator createIterator();
}
具体聚合类
public class ConcreteAggregate implements Aggregate {
......
public Iterator createIterator() {
return new ConcreteIterator(this);
}
......
}
7.注意
抽象迭代器接口的设计非常重要，一方面需要充分满足各种遍历操作的要求，尽量为各种遍历方法都提供声明，另一方面又不能包含太多方法，接口中方法太多将给子类的实现带来麻烦。
可以考虑使用抽象类来设计抽象迭代器，在抽象类中为每一个方法提供一个空的默认实现。
2）完整解决方案
1.结构图
AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。
2.代码实现
import java.util.*;
//抽象聚合类
abstract class AbstractObjectList {
protected List<Object> objects = new ArrayList<Object>();
public AbstractObjectList(List objects) {
this.objects = objects;
}
public void addObject(Object obj) {
this.objects.add(obj);
}
public void removeObject(Object obj) {
this.objects.remove(obj);
}
public List getObjects() {
return this.objects;
}
//声明创建迭代器对象的抽象工厂方法
public abstract AbstractIterator createIterator();
}
//商品数据类：具体聚合类
public class ProductList extends AbstractObjectList {
public ProductList(List products) {
super(products);
}
//实现创建迭代器对象的具体工厂方法
public AbstractIterator createIterator() {
return new ProductIterator(this);
}
}
//抽象迭代器
interface AbstractIterator {
//移至下一个元素
public void next();
//判断是否为最后一个元素
public boolean isLast();
//移至上一个元素
public void previous();
//判断是否为第一个元素
public boolean isFirst();
//获取下一个元素
public Object getNextItem();
//获取上一个元素
public Object getPreviousItem();
}
//商品迭代器：具体迭代器
public class ProductIterator implements AbstractIterator {
private ProductList productList;
private List products;
//定义一个游标，用于记录正向遍历的位置
private int cursor1;
//定义一个游标，用于记录逆向遍历的位置
private int cursor2;
public ProductIterator(ProductList list) {
//获取集合对象
this.productList = list;
this.products = list.getObjects();
//设置正向遍历游标的初始值
cursor1 = 0;
//设置逆向遍历游标的初始值
cursor2 = products.size() -1;
}
public void next() {
if(cursor1 < products.size()) {
cursor1++;
}
}
public boolean isLast() {
return (cursor1 == products.size());
}
public void previous() {
if (cursor2 > -1) {
cursor2--;
}
}
public boolean isFirst() {
return (cursor2 == -1);
}
public Object getNextItem() {
return products.get(cursor1);
}
public Object getPreviousItem() {
return products.get(cursor2);
}
}
客户端类
public class Client {
public static void main(String[] args) {
List products = new ArrayList();
products.add("倚天剑");
products.add("屠龙刀");
products.add("断肠草");
products.add("葵花宝典");
products.add("四十二章经");
AbstractObjectList list;
AbstractIterator iterator;
list = new ProductList(products); //创建聚合对象
iterator = list.createIterator(); //创建迭代器对象
System.out.println("正向遍历：");
while(!iterator.isLast()) {
System.out.print(iterator.getNextItem() + "，");
iterator.next();
}
System.out.println();
System.out.println("-----------------------------");
System.out.println("逆向遍历：");
while(!iterator.isFirst()) {
System.out.print(iterator.getPreviousItem() + "，");
iterator.previous();
}
}
}
