設計模式之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接口，這對以後對容器的遍歷提供了很大的遍歷，我們可以不需要知道怎麼實現的，直接使用即可。