设计模式之Iterator和容器与迭代器遍历

马士兵设计模式视频及源码分享链接：

链接: https://pan.baidu.com/s/1bHhkU6 密码: 35bd

Iterator本身也是四人帮本身定义的23种设计模式之一，用的并不多，一般只是出现在容器的遍历。

首先我们先写一个可以动态添加对象的容器：

public class ArrayList {
        //使用数组来模拟一个可以装任意数量的容器
        Object[] objects = new Object[10];
        int index = 0;
        public void add(Object o) {
            if (index == objects.length) {
                Object[] newObjects = new Object[objects.length * 2];
                System.arraycopy(objects, 0, newObjects,    0, objects.length);
                objects = newObjects;
            }
            objects[index++] = o;
        }
        public int size() {
            return index;
        }
    }

这个容器就是使用数组进行创建的，但是相比数组而言，不需要考虑数组边界的问题，可以进行动态扩展。我们还可以根据类型向集合中添加元素。例如我们可以创建一个猫的类型，然后在容器中对猫进行添加。

public class Cat {
        private int id;
        public Cat(int id) {
            super();
            this.id = id;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
    }

现在我们希望使用链表来实现一个集合,实现如下：

其中Node类，保存数据和指向下一个Node的引用

public class Node {
        private Object data;
        public Node(Object data, Node next) {
            super();
            this.data = data;
            this.next = next;
        }
        public Object getData() {
            return data;
        }
        public void setData(Object data) {
            this.data = data;
        }
        public Node getNext() {
            return next;
        }
        public void setNext(Node next) {
            this.next = next;
        }
        private Node next;
    }

    public class LinkedList {
        Node head = null;
        Node tail = null;
        int size = 0;
        public void add(Object o) {
            Node n = new Node(o, null);
            if (head == null) {
                head = n;
                tail = n;
            }
            tail.setNext(n);
            tail = n;
            size++;
        }
        public int size() {
            return size;
        }
    }

接下来我们考虑容器的可替换性：

什么是容器的可替换性呢，我们想对不同容器之间的相同之处给统一起来，生成一个公共的接口，这样使用的时候可以针对这些相同的方法，进行随意的切换容器。那么我们现在抽取出一个接口：

public interface Collection {
        void add(Object o);
        int size();
    }

对于ArrayList和LinkedList都实现了这个接口，那么当我们以后使用的时候，如：Collection al = new ArrayList();或者是Collection al = new LinkedList();都不需要改变很多，只需要改变实现接口的类接口的类就可以了，这使得编程更加灵活。那么新的问题又来了，对于容器而言，有一个非常重要的方法，那就是遍历。

如何对集和容器进行遍历：

正常对于ArrayList进行遍历可以使用for对索引进行遍历，但是我们发现，如果这么做的话，对于除了ArrayList以外的所有容器，我们都需要改变遍历方式，这就增大我们的工作量，而且实现的没有什么意义。每一种容器都有自己独特的遍历方式，而对于我们来说，要做的就是想办法把这些遍历方式给统一起来，那么只能使用接口，或者是抽象类。

public interface Iterator {
        Object next();
        Boolean hasNext();
        Iterator iterator();
    }
    public interface Iterator {
        Object next();
        Boolean hasNext();
    }

那么现在我们的ArrayList应该改写成：

public class ArrayList implements Collection{
        //使用数组来模拟一个可以装任意数量的容器
        Object[] objects = new Object[10];
        int index = 0;
        public void add(Object o) {
            if (index == objects.length) {
                Object[] newObjects = new Object    [objects.length * 2];
                System.arraycopy(objects, 0, newObjects, 0,     objects.length);
                objects = newObjects;
            }
            objects[index++] = o;
        }

        public int size() {
            return index;
        }

        public Iterator iterator() {

            return new ArrayListIterator();
        }
        private class ArrayListIterator implements Iterator     {

            private int currentIndex = 0;

            @Override
            public Object next() {
                Object o = objects[currentIndex++];
                return o;
            }

            @Override
            public Boolean hasNext() {
                if (currentIndex >= index) {
                    return false;
                }
                return true;
            }       
        }
    }   

查阅API：

我们可以查阅API中Iterator接口是干什么的，会发现Collection接口中具有Iterator接口，每一个实现Collection接口的类都会实现一个Iterator接口，这对以后对容器的遍历提供了很大的遍历，我们可以不需要知道怎么实现的，直接使用即可。