设计模式——迭代器模式

上次我们讲了下观察者模式《设计模式——观察者模式》，这次我们来看下迭代器模式。迭代器模式我们自己可能很少直接的使用，但是我们却经常在间接地使用，Java集合类就用到了这个模式，这个可以通过他们的源码来验证。

我们知道对容器对象的访问必然会涉及到遍历操作，一般情况下，我们的做法是将遍历的方法封装在容器中，但是这样会带来新的问题：容器类不仅要维护自身内部的数据元素，还要对外提供遍历的接口方法，这样不但显得类很臃肿，同时也违背了抽象编程原则。为了解决上面的缺点，我们可以采用迭代器模式，将遍历集合的操作与集合的底层实现的结构分离。

一，定义：

迭代器模式：提供一种方法顺序访问一个容器中的各个元素，而又不需要暴露该对象的内部表示。

二，UML类图

迭代器模式UML类图如下：



Iterator:迭代器接口，定义了两个方法。next()方法返回当前位置的元素并将位置移至下一位；hasNext()判断是否还有下一个元素。

ConcreteIterator：具体迭代器，实现了迭代器接口（Iterator）。

Aggregate：容器接口，定义了容器的基本操作：add()添加元素，remove()删除元素，iterator()获取容器的迭代器。

ConcreteAggregate：具体容器类。

三，实例

上面我们提到，Java集合类就用到迭代器模式，这里我们就以集合的源码来举例说明迭代器模式的使用。

首先，我们看下java.util.Iterator，这就是迭代器接口，它的定义如下：

public interface Iterator<E> {
/**
* Returns true if there is at least one more element, false otherwise.
* @see #next
*/
public boolean hasNext();

/**
* Returns the next object and advances the iterator.
*
* @return the next object.
* @throws NoSuchElementException
*             if there are no more elements.
* @see #hasNext
*/
public E next();

/**
* Removes the last object returned by {@code next} from the collection.
* This method can only be called once between each call to {@code next}.
*
* @throws UnsupportedOperationException
*             if removing is not supported by the collection being
*             iterated.
* @throws IllegalStateException
*             if {@code next} has not been called, or {@code remove} has
*             already been called after the last call to {@code next}.
*/
public void remove();
}

在Iterator 中定义了三个方法，比我们上面UML图中多了一个remove()方法，此方法用于将调用next()返回的对象从容器中移除。方法的定义不是重点，我们要学习的是迭代器模式的这种思想。接下来，我们再看下java.util.Collection这个接口，此接口对应的就是上面UML图中的Aggregate接口。Collection接口部分定义如下：

public interface Collection<E> extends Iterable<E> {

/**
* Attempts to add {@code object} to the contents of this
* {@code Collection} (optional).
*
* After this method finishes successfully it is guaranteed that the object
* is contained in the collection.
*
* If the collection was modified it returns {@code true}, {@code false} if
* no changes were made.
*
* An implementation of {@code Collection} may narrow the set of accepted
* objects, but it has to specify this in the documentation. If the object
* to be added does not meet this restriction, then an
* {@code IllegalArgumentException} is thrown.
*
* If a collection does not yet contain an object that is to be added and
* adding the object fails, this method <i>must</i> throw an appropriate
* unchecked Exception. Returning false is not permitted in this case
* because it would violate the postcondition that the element will be part
* of the collection after this method finishes.
*
* @param object
*            the object to add.
* @return {@code true} if this {@code Collection} is
*         modified, {@code false} otherwise.
*
* @throws UnsupportedOperationException
*                if adding to this {@code Collection} is not supported.
* @throws ClassCastException
*                if the class of the object is inappropriate for this
*                collection.
* @throws IllegalArgumentException
*                if the object cannot be added to this {@code Collection}.
* @throws NullPointerException
*                if null elements cannot be added to the {@code Collection}.
*/
public boolean add(E object);

/***
* 其他方法省略，有兴趣的可以看下源码
*/

/**
* Returns an instance of {@link Iterator} that may be used to access the
* objects contained by this {@code Collection}. The order in which the elements are
* returned by the iterator is not defined. Only if the instance of the
* {@code Collection} has a defined order the elements are returned in that order.
*
* @return an iterator for accessing the {@code Collection} contents.
*/
public Iterator<E> iterator();

/**
* Removes one instance of the specified object from this {@code Collection} if one
* is contained (optional). The element {@code elem} that is removed
* complies with {@code (object==null ? elem==null : object.equals(elem)}.
*
* @param object
*            the object to remove.
* @return {@code true} if this {@code Collection} is modified, {@code false}
*         otherwise.
* @throws UnsupportedOperationException
*                if removing from this {@code Collection} is not supported.
* @throws ClassCastException
*                if the object passed is not of the correct type.
* @throws NullPointerException
*                if {@code object} is {@code null} and this {@code Collection}
*                doesn't support {@code null} elements.
*/
public boolean remove(Object object);

这里只列举了Collection的三个方法，其他的方法我们先不讨论，感兴趣的同学可以看下java.util.Collection 的源码。到目前为止，迭代器接口、容器接口我们都列举出来了，现在我们看下他们的实现类。Collection的实现类有很多，有ArrayList、LinkedList、HashSet等。这里我们以常用的ArrayList来分析，ArrayList中的add(),remove()方法的具体实现，我们不去讨论，直接看iterator()方法

@Override public Iterator<E> iterator() {
return new ArrayListIterator();
}

private class ArrayListIterator implements Iterator<E> {
/** Number of elements remaining in this iteration */
private int remaining = size;

/** Index of element that remove() would remove, or -1 if no such elt */
private int removalIndex = -1;

/** The expected modCount value */
private int expectedModCount = modCount;

public boolean hasNext() {
return remaining != 0;
}

@SuppressWarnings("unchecked") public E next() {
ArrayList<E> ourList = ArrayList.this;
int rem = remaining;
if (ourList.modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (rem == 0) {
throw new NoSuchElementException();
}
remaining = rem - 1;
return (E) ourList.array[removalIndex = ourList.size - rem];
}

public void remove() {
Object[] a = array;
int removalIdx = removalIndex;
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
if (removalIdx < 0) {
throw new IllegalStateException();
}
System.arraycopy(a, removalIdx + 1, a, removalIdx, remaining);
a[--size] = null;  // Prevent memory leak
removalIndex = -1;
expectedModCount = ++modCount;
}
}

从代码中可以看出：iterator()方法返回了一个ArrayListIterator对象，而这个ArrayListIterator是ArrayList的内部类，它实现了Iterator接口。至于三个方法的具体实现，它们会涉及到ArrayList底层实现的内容，这里也不做讨论了，有时间以后再写下有关ArrayList底层实现的原理的文章。

最后总结下，迭代器模式让我们能访问容器中每个元素，而又不暴露其内部的表示；这种模式把遍历的任务放在了迭代器上，而不是容器上，这样简化了容器的接口和实现，也让责任各得其所。