Java设计模式（二）——迭代模式

/*
 * 设计迭代接口
 */
public interface Iterator<E> {
    // 测试是否有下一个元素
    boolean hasNext();
    // 返回下一个元素
    E next();
}

/*
 * 设计一个集合对象
 */
public interface Collection<E> {
    void add(E e);
    E get(int index);
    int size();
    // 要求实现类根据自身的特点实现迭代方法
    Iterator<E> iterator();
}

/*
 * 模拟jdk中ArrayList的实现
 */
public class ArrayList<E> implements Collection<E>, Iterator<E> {
    // 迭代下标
    private int iteratorIndex = 0;
    // 初始化的数组大小
    private Object[] objects = new Object[10];
    // 数组下标
    private int index = 0;

    @Override
    public void add(E e) {
        if (index == objects.length) {
            // 数组的增长的步长为10
            Object[] newObjects = new Object[objects.length + 10];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }
        objects[index] = e;
        index++;
    }

    // 通过ArrayList读取元素是一次性的，开销较小
    @Override
    public E get(int index) {
        if (index < this.index) {
            return (E) objects[index];
        } else {
            return null;
        }
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public Iterator<E> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        if (iteratorIndex < index) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public E next() {
        if (iteratorIndex < index) {
            E e = get(iteratorIndex);
            iteratorIndex++;
            return e;
        } else {
            return null;
        }
    }
}

package iterator.jdk;
/*
 * 模拟jdk中LinkedList的实现
 */
public class LinkedList<E> implements Collection<E>, Iterator<E> {
    // 迭代下标
    private int iteratorIndex = 0;
    // 链表长度，随元素的数量逐步递增
    private int len = 0;
    
    private Node<E> headNode;
    private Node<E> tailNode;
    private Node<E> point;

    // 内部类实现链表对象的存储
    private class Node<E> {
        E e;
        Node<E> next;

        Node(E e, Node<E> next) {
            this.e = e;
            this.next = next;
        }

        public Object get() {
            return e;
        }

        public Node<E> getNext() {
            return next;
        }

        public void setNext(Node<E> next) {
            this.next = next;
        }
    }

    @Override
    public void add(E e) {
        // len==0既是把头元素放入也是将链表初始化
        if (len == 0) {
            headNode = new Node<E>(e, null);
            tailNode = headNode;
            point = headNode;
            len++;
        } else {
            Node<E> node = new Node<E>(e, null);
            tailNode.setNext(node);
            tailNode = node;
            len++;
        }
    }

    // 通过LinkedList每次读取元素都是一次迭代的过程，开销较大
    @Override
    public E get(int index) {
        if (index == 0) {
            return (E) headNode.get();
        } else if (index > 0 && index < this.len) {
            Node<E> node = headNode;
            for (int i = 1; i <= index; i++) {
                node = node.getNext();
            }
            return (E) node.get();
        } else {
            return null;
        }
    }

    @Override
    public int size() {
        return len;
    }

    @Override
    public Iterator<E> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        if (iteratorIndex < len) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public E next() {
        if (iteratorIndex < len) {
            E e = (E) point.get();
            point = point.getNext();
            iteratorIndex++;
            return e;
        } else {
            return null;
        }
    }

}