定义:提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。
代码模拟实现迭代器:
1、定义集合接口
public interface Collection_ {
void add(Object o);
int size();
Iterator_ iterator();
}
2、定义迭代器
public interface Iterator_ {
boolean hasNext();
Object next();
}
3、实现集合1
/**
* 相比数组,这个容器不用考虑边界问题,可以动态扩展
*/
class ArrayList_ implements Collection_ {
Object[] objects = new Object[10];
//objects中下一个空的位置在哪儿,或者说,目前容器中有多少个元素
private int index = 0;
public void add(Object o) {
if(index == objects.length) {
Object[] newObjects = new Object[objects.length*2];
System.arraycopy(objects, 0, newObjects, 0, objects.length);
objects = newObjects;
}
objects[index] = o;
index ++;
}
public int size() {
return index;
}
@Override
public Iterator_ iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator implements Iterator_{
private int currentIndex = 0;
@Override
public boolean hasNext() {
if(currentIndex >= index) return false;
return true;
}
@Override
public Object next() {
Object o = objects[currentIndex];
currentIndex ++;
return o;
}
}
}
4、实现集合2
/**
* 相比数组,这个容器不用考虑边界问题,可以动态扩展
*/
class LinkedList_ implements Collection_ {
Node head = null;
Node tail = null;
//目前容器中有多少个元素
private int size = 0;
public void add(Object o) {
Node n = new Node(o);
n.next = null;
if(head == null) {
head = n;
tail = n;
}
tail.next = n;
tail = n;
size++;
}
private class Node {
private Object o;
Node next;
public Node(Object o) {
this.o = o;
}
}
public int size() {
return size;
}
@Override
public Iterator_ iterator() {
return null;
}
}
5、测试类
public class Main {
public static void main(String[] args) {
Collection_ list = new ArrayList_();
for(int i=0; i<15; i++) {
list.add(new String("s" + i));
}
System.out.println(list.size());
//这个接口的调用方式:
Iterator_ it = list.iterator();
while(it.hasNext()) {
Object o = it.next();
System.out.println(o);
}
}
}
总结:
优点:
1、它支持以不同的方式遍历一个聚合对象。
2、迭代器简化了聚合类。
3、在同一个聚合上可以有多个遍历。
4、在迭代器模式中,增加新的聚合类和迭代器类都很方便,无须修改原有代码
缺点
由于迭代器模式将存储数据和遍历数据的职责分离,增加新的聚合类需要对应增加新的迭代器类,类的个数成对增加,这在一定程度上增加了系统的复杂性。