正文
在
JDK中已經(jīng)為我們提供了大量實現(xiàn)了迭代器的容器類磺平。
因此我們可以不用關(guān)心遏佣，諸如：Linkedlist與ArrayList之間的差別捉貌，卻仍能保障我們完成工作昔穴。
現(xiàn)在我們需要思索霹菊，JDK是怎么做到這一切的剧蚣？現(xiàn)在讓我們先利用迭代器實現(xiàn)一個數(shù)組類型Array，這個類型需要支持添加旋廷、移除鸠按、遍歷操作。
實現(xiàn)
STEP 1
定義迭代器接口饶碘，實現(xiàn)該接口的類擁有迭代器職責目尖。這叫好像在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
實現(xiàn)一個數(shù)組Array模擬數(shù)組的操作琉挖，所有訪問集合中元素的操作全權(quán)委托給iterator對象。Array并不關(guān)心操作元素的細節(jié)涣脚，它只向外暴露操作接口示辈，對收到的請求轉(zhuǎn)發(fā)給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
定義迭代器實現(xiàn)類遣蚀，使用接口抽象迭代器是為了滿足開閉原則矾麻，這樣Array可以隨時更換迭代器而不會影響現(xiàn)有的接口。
ArrayIteratorImpl迭代器實現(xiàn)了對數(shù)組的添加芭梯、移除操作险耀，如何分配元素、選擇用什么容器存儲玖喘、遍歷的順序甩牺、甚至是否啟用并行操作，這些對于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
客戶端調(diào)用測試
public class Client {
public static void main(String[] args) {
Array<String> array = new Array();
array.add("清華大學(xué)");
array.add("北京大學(xué)");
array.add("浙江大學(xué)");
array.add("武漢大學(xué)");
array.add("西安交通大學(xué)");
array.add("上海交通大學(xué)");
array.add("人民大學(xué)");
Iterator<String> iterator = array.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
System.out.println(item);
}
}
}
總結(jié)
迭代器模式屬于行為模式類別贬派。
迭代器本質(zhì)：控制訪問集合中的元素
迭代器模式.png
