## 定義 ##

提供一種方法順序訪問一個聚合物件中的各個元素，而由不需要暴露該物件的內部細節。

## 程式碼舉例 ##

/**
 * @author bwx
 * @date 2017/11/29
 * 迭代器介面
 */
public interface MyIterator<E> {
    /**
     * 判斷是否還有下一個元素
     * @return
     */
    boolean hasNext();
    E next();
    void remove();
}

/**
 * @author bwx
 * @date 2017/11/29
 * 集合介面
 */
 

public interface MyList<E> {
    /**
     * 返回集合大小
     * @return
     */
    int size();

    /**
     * 返回迭代物件
     * @return
     */
    MyIterator<E> iterator();

    /**
     * 新增集合物件
     * @param e
     * @return
     */
    boolean add(E e);

    /**
     * 如果該元素存在，移除指定元素
     * 如果(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))，
     * 則刪除下標最小的元素
     * @param
 
 o
     * @return
     */
    boolean remove(Object o);

    /**
     * 移除指定位置的元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 得到指定下標的元素
     * @param index
     * @return
     */
    E get(int index);

    /**
     * 修改
     * @param index
     * @param element
     * @return
 

     */
    E set(int index, E element);
}

/**
 * @author bwx
 * @date 2017/11/29
 * 陣列集合
 */
public class MyArrayList<E> implements MyList<E> {
    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    /**
     * 集合大小
     */
    private int size;

    /**
     * 集合預設容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 集合陣列
     */
    private Object[] elementData;

    public MyArrayList() {
        elementData = new Object[DEFAULT_CAPACITY];
    }

    /**
     * 返回集合大小
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 返回迭代物件
     *
     * @return
     */
    public MyIterator<E> iterator() {
        return new Iterator();
    }

    private class Iterator implements MyIterator<E> {
        /**
         * 遊標，下一個元素的下標
         */
        int cursor;
        /**
         * 判斷是否還有下一個元素
         *
         * @return
         */
        public boolean hasNext() {
            return cursor != size;
        }

        public E next() {
            int i = cursor;
            if (i >= size) {
                return null;
            }
            Object[] elementData = MyArrayList.this.elementData;
            if (i >= elementData.length) {
                return null;
            }
            cursor = i + 1;
            return (E) elementData[i];
        }

        public void remove() {
            int i = cursor - 1;
            MyArrayList.this.remove(i);
            cursor = cursor==0? 0 : cursor;
        }
    }

    /**
     * 自動擴充陣列的容量，防止溢位
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
        int nowLen = elementData.length;
        if (capacity >= nowLen) {
            nowLen = nowLen + (nowLen >> 1);
            if (nowLen - capacity < 0) {
                nowLen = capacity;
            }
            if (nowLen - MAX_ARRAY_SIZE > 0) {
                nowLen = (capacity > MAX_ARRAY_SIZE) ?
                        Integer.MAX_VALUE :
                        MAX_ARRAY_SIZE;
            }
            //noinspection Since15
            elementData = Arrays.copyOf(elementData, nowLen);
        }
    }

    /**
     * 新增集合物件
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        ensureCapacity(size + 1);
        elementData[size++] = e;
        return true;
    }

    /**
     * 如果該元素存在，移除指定元素
     * 如果(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))，
     * 則刪除下標最小的元素
     *
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        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;
    }

    /**
     * 刪除元素
     * @param index
     */
    private void fastRemove(int index) {
        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
    }

    /**
     * 移除指定位置的元素
     *
     * @param index
     * @return
     */
    public E remove(int index) {
        if(index<0 || index>=size) {
            return null;
        }
        E oldValue = (E) elementData[index];

        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

        return oldValue;
    }

    /**
     * 得到指定下標的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if(index<0 || index>=size) {
            return null;
        }
        return (E) elementData[index];
    }

    /**
     * 修改
     *
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element) {
        if(index<0 || index>=size) {
            return null;
        }

        E oldValue = (E) elementData[index];
        elementData[index] = element;
        return oldValue;
    }

}

/**
 * @author bwx
 * @date 2017/11/29
 * 連結串列集合
 */
public class MyLinkedList<E> implements MyList<E> {
    int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    Node<E> last;

    private class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    /**
     * 返回集合大小
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 返回迭代物件
     *
     * @return
     */
    public MyIterator<E> iterator() {
        return new Iterator();
    }

    private class Iterator implements MyIterator<E> {

        private Node<E> node;

        public Iterator() {
            node = first;
        }

        /**
         * 判斷是否還有下一個元素
         *
         * @return
         */
        public boolean hasNext() {
            return node.next != null;
        }

        public E next() {
            if (!hasNext()) {
                return null;
            }
            Node<E> eNode = node;
            node = node.next;
            return eNode.item;
        }

        public void remove() {
            unlink(node);
        }
    }

    /**
     * 新增集合物件
     *
     * @param e
     * @return
     */
    public boolean add(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<E>(l, e, null);
        last = newNode;
        if (l == null) {
            first = newNode;
        } else {
            l.next = newNode;
        }
        size++;
        return true;
    }

    /**
     * 如果該元素存在，移除指定元素
     * 如果(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))，
     * 則刪除下標最小的元素
     *
     * @param o
     * @return
     */
    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> node = first; node != null; node = node.next) {
                if (node.item == null) {
                    unlink(node);
                    return true;
                }
            }
        } else {
            for (Node<E> node = first; node != null; node = node.next) {
                if (o.equals(node.item)) {
                    unlink(node);
                    return true;
                }
            }
        }
        return false;
    }

    private E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        return element;
    }

    /**
     * Returns the (non-null) Node at the specified element index.
     */
    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--) {
                x = x.prev;
            }
            return x;
        }
    }

    /**
     * 移除指定位置的元素
     *
     * @param index
     * @return
     */
    public E remove(int index) {
        return unlink(node(index));
    }

    /**
     * 得到指定下標的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        return node(index).item;
    }

    /**
     * 修改
     *
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element) {
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }
}

/**
 * @author bwx
 * @date 2017/11/29
 * 迭代器模式
 */
public class Main {
    public static void main(String[] args) {
        //分別定義兩種結構
        MyList<String> array = new MyArrayList<String>();
        MyList<String> link = new MyLinkedList<String>();
        //新增資料
        for(int i = 1;i < 15; i++){
            array.add(i+"");
            link.add(i+"");
        }
        //陣列操作
        System.out.println("=======陣列操作===========");
        System.out.println(array.remove("5"));
        System.out.println(array.get(5));
        System.out.println(array.remove(5));
        System.out.println(array.get(5));
        System.out.println(array.remove("7"));
        System.out.println(array.set(0, "零"));
        //使用迭代器
        MyIterator<String> ai = array.iterator();
        while(ai.hasNext()) {
            System.out.print(ai.next() + " ");
        }
        System.out.println("=======陣列操作===========");
        System.out.println();
        System.out.println("=======連結串列操作===========");
        System.out.println(link.remove("5"));
        System.out.println(link.get(5));
        System.out.println(link.remove(5));
        System.out.println(link.get(5));
        System.out.println(link.remove("7"));
        System.out.println(link.set(0, "零"));
        //使用迭代器
        MyIterator<String> li = link.iterator();
        while(li.hasNext()) {
            System.out.print(li.next() + " ");
        }
        System.out.println();
        System.out.println("a size=" + array.size());
        System.out.println("l size=" + link.size());
        System.out.println("=======連結串列操作===========");
    }
}

## 優點 ##

• 使用者使用迭代器訪問集合中的物件而不需要知道這個集合的具體實現

• 可以同時使用多個迭代器遍歷一個集合

  優點

• 程式碼參照LinkedList，ArrayList實現。