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

迭代模式的基本定义：对于一组对象集合（数组、堆栈、列表或散列），用户无需关心它的底层实现而能够通过调用统一接口遍历当中的所有元素。由于jdk已经对常见的迭代模式实现了封装，本文直接提供Collection和Iterator两个接口的模拟。

定义Iterator接口

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

Iterator.java

定义Collection接口

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

Collection.java

对于任何实现了接口的集合都能很方便的查找或遍历其中的元素。

创建使用数组方式存放元素集合的类：ArrayList

/*
 * 模拟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;
        }
    }
}

ArrayList.java

创建使用链表方式存放元素集合的类：LinkedList

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;
        }
    }

}

LinkedList.java

附：JDK容器分类