正文
在
JDK中已经为我们提供了大量实现了迭代器的容器类。
因此我们可以不用关心，诸如：Linkedlist与ArrayList之间的差别，却仍能保障我们完成工作。
现在我们需要思索，JDK是怎么做到这一切的？现在让我们先利用迭代器实现一个数组类型Array，这个类型需要支持添加、移除、遍历操作。
实现
STEP 1
定义迭代器接口，实现该接口的类拥有迭代器职责。这叫好像在20年前，家门口停了一辆小汽车，别人都会知道你是万元户一样。
public interface Iterable<T> {
Iterator<T> iterator();
}
STEP 2
定义迭代器对象，除却基本的hasNext、next方法。额外定义了add、remove方法，这会辅助我们操作集合中的元素。
注意：迭代器不仅仅为了
{迭代}，而是为了{操作}集合中的元素。
public interface Iterator<E> {
boolean hasNext();
E next();
boolean add(E e);
boolean addAll(Collection<? extends E> e);
boolean remove(E e);
}
STEP 3
实现一个数组Array模拟数组的操作，所有访问集合中元素的操作全权委托给iterator对象。Array并不关心操作元素的细节，它只向外暴露操作接口，对收到的请求转发给iterator处理。
public class Array<E> implements Iterable<E> {
private transient Iterator<E> iterator;
public Array() {
this.iterator = iterator();
}
public Array(Collection<? extends E> collection) {
this.iterator = iterator();
this.iterator.addAll(collection);
}
@Override
public Iterator<E> iterator() {
synchronized (this) {
if (iterator == null) {
iterator = new ArrayIteratorImpl<>();
}
}
return iterator;
}
public void add(E e) {
this.iterator.add(e);
}
public void addAll(Collection<? extends E> e) {
this.iterator.addAll(e);
}
public void remove(E e) {
this.iterator.remove(e);
}
}
STEP 4
定义迭代器实现类，使用接口抽象迭代器是为了满足开闭原则，这样Array可以随时更换迭代器而不会影响现有的接口。
ArrayIteratorImpl迭代器实现了对数组的添加、移除操作，如何分配元素、选择用什么容器存储、遍历的顺序、甚至是否启用并行操作，这些对于Array都是不可感知的。
public class ArrayIteratorImpl<E> implements Iterator<E> {
private transient Object[] elementData = {};
private transient static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
protected transient int modCount = 0;
private int size;
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
@Override
public boolean hasNext() {
return cursor != size;
}
@Override
public E next() {
int i = cursor;
if (i >= size)
throw new IllegalArgumentException("");
Object[] elementData = this.elementData;
if (i >= elementData.length)
throw new IllegalArgumentException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
@Override
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
lastRet = -1;
return true;
}
@Override
public boolean addAll(Collection<? extends E> e) {
final Object[] a = e.toArray();
final int numNew = e.size();
ensureCapacityInternal(this.size + numNew);
System.arraycopy(a, 0, elementData, size, numNew);
this.size += numNew;
lastRet = -1;
return numNew != 0;
}
@Override
public boolean remove(E o) {
lastRet = -1;
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
}
STEP 5
客户端调用测试
public class Client {
public static void main(String[] args) {
Array<String> array = new Array();
array.add("清华大学");
array.add("北京大学");
array.add("浙江大学");
array.add("武汉大学");
array.add("西安交通大学");
array.add("上海交通大学");
array.add("人民大学");
Iterator<String> iterator = array.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
}
}
总结
迭代器模式属于行为模式类别。
迭代器本质：控制访问集合中的元素
迭代器模式.png
