java设计模式之迭代器模式

java设计模式参考文章：
Java设计模式实战，23种设计模式介绍以及在Java中的实现，Java设计模式， Java经典设计模式之五大创建型模式

---

## 定义 ##

提供一种方法顺序访问一个聚合对象中的各个元素，而由不需要暴露该对象的内部细节。

## 代码举例 ##

/**
 * @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实现。