迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。
迭代器的思想是把聚合對象的遍历和访问从聚合对象中分离出来，放入单独的迭代器中，实现聚合对象和遍历的解耦。
(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),
(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。
(3)容器角色(Aggregate): 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等
(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。
这里就不单独举例子了，直接看list中的迭代器即可：
public interface Iterator<E> {
boolean hasNext();
E next();
default void remove() {
throw new UnsupportedOperationException("remove");
}
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
最后一个方法是java8之后提供的，跟函数式编程有关，可以使用lambda表达式遍历
再来看他的实现：
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
很简单，因为直接使用的内部类，所以很方便的访问ArrayList中元素，当然如果是我们自己设计的话，可能迭代器的实现是一个外部类，而其中会有一个ArrayList的对象。
通过这个迭代器，倒是看明白了ArrayList中如果遍历的时候remove的话可能有问题。比如：
List<String> list = new ArrayList<>();
for(int i = 0; i <10 ;i++){
list.add("test " + i);
}
for (int i = 0; i < list.size(); i++){
if(i == 3){
list.remove(i);
}else{
System.out.println(list.get(i));
}
}
输出的话，就会少输出 test 4 这个数据，为什么呢？ 因为ArrayList内部是数组存储，remove(3)之后，所有的数据在数组都会前移，所以原来放test 3的现在放了test 4，而i++ 之后，移到了下一个位置，所以就错过了。当然，如果这么遍历的话，就直接数组越界了：
int size = list.size();
for (int i = 0; i < size; i++){
if(i == 3){
list.remove(i);
}else{
System.out.println(list.get(i));
}
}
迭代器中实现的remove，位置还是当前的位置，所以不会出错。所以ArrayList中遍历的时候，要么使用迭代器删除，要么自己实现的时候，i不要++，比如：
for (int i = 0; i < list.size();){
if(i == 3){
list.remove(i);
}else{
System.out.println(list.get(i));
i++;
}
}
ArrayList中还实现了另外一个迭代器，ListIterator。 这个包含了向前遍历的方法：
boolean hasPrevious();
E previous();
