遍历聚合对象中的元素——迭代器模式
迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。
在迭代器模式结构中包含聚合和迭代器两个层次结构，考虑到系统的灵活性和可扩展性，在迭代器模式中应用了工厂方法模式，其模式结构如图3所示：
在迭代器模式结构图中包含如下几个角色：
● Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。
● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。
● ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。
在抽象迭代器中声明了用于遍历聚合对象中所存储元素的方法，典型代码如下所示：
interface Iterator { public void first(); //将游标指向第一个元素 public void next(); //将游标指向下一个元素 public boolean hasNext(); //判断是否存在下一个元素 public Object currentItem(); //获取游标指向的当前元素 }
在具体迭代器中将实现抽象迭代器声明的遍历数据的方法，如下代码所示：
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(); }
具体聚合类作为抽象聚合类的子类，一方面负责存储数据，另一方面实现了在抽象聚合类中声明的工厂方法createIterator()，用于返回一个与该具体聚合类对应的具体迭代器对象，代码如下所示：
class ConcreteAggregate implements Aggregate { ...... public Iterator createIterator() { return new ConcreteIterator(this); } ...... }
软件公司为某商场开发了一套销售管理系统，在对该系统进行分析和设计时，软件公司开发人员发现经常需要对系统中的商品数据、客户数据等进行遍历，为了复用这些遍历代码，公司开发人员设计了一个抽象的数据集合类AbstractObjectList，而将存储商品和客户等数据的类作为其子类，AbstractObjectList类结构如图2所示：
图2 AbstractObjectList类结构图
AbstractObjectList类方法说明
AbstractObjectList()
构造方法，用于给objects对象赋值
addObject()
增加元素
removeObject()
删除元素
getObjects()
获取所有元素
next()
移至下一个元素
isLast()
判断当前元素是否是最后一个元素
previous()
移至上一个元素
isFirst()
判断当前元素是否是第一个元素
getNextItem()
获取下一个元素
getPreviousItem()
获取上一个元素
为了简化AbstractObjectList类的结构，并给不同的具体数据集合类提供不同的遍历方式，软件公司开发人员使用迭代器模式来重构AbstractObjectList类的设计，重构之后的销售管理系统数据遍历结构如图4所示：
图4 销售管理系统数据遍历结构图
在图4中，AbstractObjectList充当抽象聚合类，ProductList充当具体聚合类，AbstractIterator充当抽象迭代器，ProductIterator充当具体迭代器。完整代码如下所示：
抽象聚合类：
//抽象聚合类 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(); }
具体聚合类：
//商品数据类：具体聚合类 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(); //获取上一个元素 }
具体迭代器：
//商品迭代器：具体迭代器 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); } }
编写如下客户端测试代码：
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(); } } }
4 使用内部类实现迭代器
在迭代器模式结构图中，我们可以看到具体迭代器类和具体聚合类之间存在双重关系，其中一个关系为关联关系，在具体迭代器中需要维持一个对具体聚合对象的引用，该关联关系的目的是访问存储在聚合对象中的数据，以便迭代器能够对这些数据进行遍历操作。
除了使用关联关系外，为了能够让迭代器可以访问到聚合对象中的数据，我们还可以将迭代器类设计为聚合类的内部类，JDK中的迭代器类就是通过这种方法来实现的，如下AbstractList类代码片段所示：
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> { ...... private class Itr implements Iterator<E> { int cursor = 0; ...... } …… }
将ProductIterator类作为ProductList类的内部类，代码如下所示：
//商品数据类：具体聚合类 class ProductList extends AbstractObjectList { public ProductList(List products) { super(products); } public AbstractIterator createIterator() { return new ProductIterator(); } //商品迭代器：具体迭代器，内部类实现 private class ProductIterator implements AbstractIterator { private int cursor1; private int cursor2; public ProductIterator() { cursor1 = 0; cursor2 = objects.size() -1; } public void next() { if(cursor1 < objects.size()) { cursor1++; } } public boolean isLast() { return (cursor1 == objects.size()); } public void previous() { if(cursor2 > -1) { cursor2--; } } public boolean isFirst() { return (cursor2 == -1); } public Object getNextItem() { return objects.get(cursor1); } public Object getPreviousItem() { return objects.get(cursor2); } } }
5 JDK内置迭代器
在Java集合框架中，常用的List和Set等聚合类都继承（或实现）了java.util.Collection接口，在Collection接口中声明了如下方法（部分）：
package java.util; public interface Collection<E> extends Iterable<E> { …… boolean add(Object c); boolean addAll(Collection c); boolean remove(Object o); boolean removeAll(Collection c); boolean remainAll(Collection c); Iterator iterator(); …… }
JDK中定义了抽象迭代器接口Iterator，代码如下所示：
package java.util; public interface Iterator<E> { boolean hasNext(); E next(); void remove(); }
Java迭代器工作原理如图5所示，在第一个next()方法被调用时，迭代器游标由“元素1”与“元素2”之间移至“元素2”与“元素3”之间，跨越了“元素2”，因此next()方法将返回对“元素2”的引用；在第二个next()方法被调用时，迭代器由“元素2”与“元素3”之间移至“元素3”和“元素4”之间，next()方法将返回对“元素3”的引用，如果此时调用remove()方法，即可将“元素3”删除。
如下代码片段可用于删除聚合对象中的第一个元素：
Iterator iterator = collection.iterator(); //collection是已实例化的聚合对象 iterator.next(); // 跳过第一个元素 iterator.remove(); // 删除第一个元素
如下代码片段可用于删除两个相邻的元素：
iterator.remove(); iterator.next(); //如果删除此行代码程序将抛异常 iterator.remove();
在JDK中，Collection接口和Iterator接口充当了迭代器模式的抽象层，分别对应于抽象聚合类和抽象迭代器，而Collection接口的子类充当了具体聚合类，下面以List为例加以说明，图6列出了JDK中部分与List有关的类及它们之间的关系：
既然有了iterator()方法，为什么还要提供一个listIterator()方法呢？这两个方法的功能不会存在重复吗？干嘛要多此一举？
由于在Iterator接口中定义的方法太少，只有三个，通过这三个方法只能实现正向遍历，而有时候我们需要对一个聚合对象进行逆向遍历等操作，因此在JDK的ListIterator接口中声明了用于逆向遍历的hasPrevious()和previous()等方法，如果客户端需要调用这两个方法来实现逆向遍历，就不能再使用iterator()方法来创建迭代器了，因为此时创建的迭代器对象是不具有这两个方法的。我们只能通过如下代码来创建ListIterator类型的迭代器对象：
ListIterator i = c.listIterator();
在Java语言中，我们可以直接使用JDK内置的迭代器来遍历聚合对象中的元素，下面的代码演示了如何使用Java内置的迭代器：
import java.util.*; class IteratorDemo { public static void process(Collection c) { Iterator i = c.iterator(); //创建迭代器对象 //通过迭代器遍历聚合对象 while(i.hasNext()) { System.out.println(i.next().toString()); } } public static void main(String args[]) { Collection persons; persons = new ArrayList(); //创建一个ArrayList类型的聚合对象 persons.add("张无忌"); persons.add("小龙女"); persons.add("令狐冲"); persons.add("韦小宝"); persons.add("袁紫衣"); persons.add("小龙女"); process(persons); } }
该代码运行结果如下：
张无忌
小龙女
令狐冲
韦小宝
袁紫衣
小龙女
浙公网安备 33010602011771号