总纲

• 设计原则：遵循迪米特
• 常用场景：需要迭代访问一个聚合对象中的各个元素，且不暴露该聚合对象内部的表示
• 使用概率：99.99999%
• 复杂度：中
• 变化点：聚合对象的种类
• 选择关键点：客户端是否关心遍历的次序
• 逆鳞：无
• 相关设计模式
  1. 访问者模式：二者都是迭代的访问一个聚合对象中的各个元素，不同的是，访问者模式中，扩展开放的部分在作用于对象的操作上，而迭代器模式中，扩展开放的部分在聚合对象的种类上，而且二者的实现方式也有着很大的区别。
• 定义: 提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示

迭代器模式

    public interface Iterator<E> {

        boolean hasNext();

        E next();

        void remove();
    }

    public interface Iterable<T> {

        Iterator<T> iterator();
    }

    public class LinkedList<E> implements Iterable<E>{

        private Entry<E> header = new Entry<E>(null, null, null);
        private int size;

        public LinkedList() {
            header.next = header.previous = header;
        }

        public void add(E e){
            Entry<E> newEntry = new Entry<E>(e, header, header.next);
            newEntry.previous.next = newEntry;
            newEntry.next.previous = newEntry;
            size++;
        }

        public int size(){
            return size;
        }

        public Object[] toArray(){
            Object[] result = new Object[size];
            int i = size - 1;
            for (Entry<E> e = header.next; e != header; e = e.next)
                result[i--] = e.value;
            return result;
        }

        private static class Entry<E>{
            E value;
            Entry<E> previous;
            Entry<E> next;
            public Entry(E value, Entry<E> previous, Entry<E> next) {
                super();
                this.value = value;
                this.previous = previous;
                this.next = next;
            }
        }

        public Iterator<E> iterator() {
            return new Itr();
        }

        private class Itr implements Iterator<E> {

            Entry<E> current = header;

            public boolean hasNext() {
                return current.previous != header;
            }

            public E next() {
                E e = current.previous.value;
                current = current.previous;
                return e;
            }

            public void remove() {

            }

        }

    }

    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        for (int i = 1; i <= 11; i++) {
            arrayList.add(i);
        }
        System.out.println("arrayList size:" + arrayList.size());
        Iterator<Integer> arrayListIterator = arrayList.iterator();
        while (arrayListIterator.hasNext()) {
            System.out.println(arrayListIterator.next());
        }
    }