【JAVA】设计模式之迭代器（Iterator）模式的使用分析

迭代器模式属于GOF提出的23种设计模式之一，GOF对它的定义是：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。它是一种只应用于容器对象遍历的设计模式，比如我们自己定义了一种数据结构，就可以让它实现Iterable接口，用迭代器的方式来遍历这种自定义数据结构。迭代器模式比较简单也不太受到大家的关注。在我们平常的开发过程中，可能经常会用到java为我们封装好的容器迭代器的遍历方式，比如遍历ArrayList我们可以用for循环遍历，也可以用Iterator的遍历。iterator()是Iterable接口所包含的方法，Collection接口继承了Iterable接口，所以所有实现Collection接口的容器都可以直接使用迭代器的方式来遍历。由于java已经为我们对容器对象做了很好的封装，我们平时其实很少会自己实现迭代器模式。
我们通过自己手工实现一个简单的ArrayList和LinkedList容器，来为大家描述一下迭代器模式的具体使用。
第一步：手工实现一个简单的ArrayList 和 LinkedList容器
1、第一个文件：Collection接口

public interface Collection {

    /**
     * 添加元素
     * @param o
     */
    public void add(Object o);

    /**
     * 返回大小
     * @return
     */
    public int size();

    /**
     * 迭代方法
     * @return
     */
    public Iterator iterator();
}

2、第二个文件：MyArrayList容器实现类

public class MyArrayList implements Collection {

    /**
     * List成员
     */
    private Object[] elementData;

    /**
     * List长度
     */
    private int size;

    /**
     * 构造方法
     * @param elementData
     * @param size
     */
    public MyArrayList(int size) {
        super();
        this.elementData = new Object[size];
        this.size = 0;
    }

    public MyArrayList(){
        this(10); //默认创建容器长度为10
    }

    /**
     * 添加元素
     */
    public void add(Object o){
        if(this.size >= 10){
            int newSize = size * 3;
            elementData = Arrays.copyOf(elementData, newSize);
        }
        elementData[size] = o;
        size++;
    }

    /**
     * 返回容器长度
     * @return
     */
    public int size(){
        return size;
    }

    public Object get(int size){
        return elementData[size];
    }
}

3、第三个文件：LinkedList实现类

public class MyLinkedList implements Collection{

    /**
     * 头结点
     */
    private Node head = null;

    /**
     * 当前大小
     */
    private int size = 0;

    /**
     * 尾节点
     */
    private Node tail = null;

    /**
     * 添加元素
     * @param o
     */
    public void add(Object o){
        Node node = new Node(o,null);
        if(head == null){ //如果头结点为空
            head = node;
            tail = node;
            node.setNext(null);
        }else{
            tail.setNext(node);
            tail = node;
        }
        size++;
    }

    /**
     * 获取长度
     * @return
     */
    public int size(){
        return size;
    }
}

4、第四个文件：Node实体类

public class Node {

    /**
     * 链表数据本身
     */
    private Object data;

    /**
     * 指向链表下一个元素
     */
    private Node next;

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

5、第五个文件：测试Main方法

/**
 * 测试Main方法
 */
public class TestMain {

    public static void main(String [] args){
        Collection c1 = new MyArrayList();
        for(int i=0;i<5;i++){
            Object o = new Object();
            System.out.println("序号：" + i + " 对象：" + o);
            c1.add(o);
        }

        Collection c2 = new MyLinkedList();
        for(int i=0;i<5;i++){
            Object o = new Object();
            System.out.println("序号：" + i + " 对象：" + o);
            c2.add(o);
        }
    }
}

好了，写到这里我们就简单实现了两个容器对象，大家可以想一个问题：如何没有迭代器模式，那我们要如何遍历这两种容器呢？答案是只能通过for循环的方式来遍历，但基于数组实现的ArrayList和基于链表实现的LinkedList的遍历方式肯定是不一样的，如果我们的系统有一个需求原来是基于ArrayList实现的，现在要替换成LinkedList来实现，那是不是很多遍历的方法都要修改？这个时候我们就可以考虑使用迭代器模式了，迭代器模式的功能就是为我们提供一种通用的容器遍历方式，下面我们将迭代器模式加入到工程中去。
第二步：迭代器模式的具体实现
1、第一个文件：迭代器模式接口Iterator.java

public interface Iterator {

    /**
     * 返回下一个对象
     * @return
     */
    Object next();

    /**
     * 是否还有下一个元素
     * @return
     */
    boolean hasNext();

}

2、第二个文件：ArrayList实现类

public class MyArrayList implements Collection {

    /**
     * List成员
     */
    private Object[] elementData;

    /**
     * List长度
     */
    private int size;

    /**
     * 构造方法
     * @param elementData
     * @param size
     */
    public MyArrayList(int size) {
        super();
        this.elementData = new Object[size];
        this.size = 0;
    }

    public MyArrayList(){
        this(10); //默认创建容器长度为10
    }

    /**
     * 添加元素
     */
    public void add(Object o){
        if(this.size >= 10){
            int newSize = size * 3;
            elementData = Arrays.copyOf(elementData, newSize);
        }
        elementData[size] = o;
        size++;
    }

    /**
     * 返回容器长度
     * @return
     */
    public int size(){
        return size;
    }

    public Object get(int size){
        return elementData[size];
    }

    public Iterator iterator(){
        return new ArrayListIterator();
    }

    /**
     * 迭代器的内部类实现
     */
    private class ArrayListIterator implements Iterator{

        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            if(currentIndex >= size)return false;
            else return true;
        }


        @Override
        public Object next() {
            // TODO Auto-generated method stub
            Object o = elementData[currentIndex];
            currentIndex++;
            return o;
        }
    }
}

3、第三个文件：LinkedList实现类

public class MyLinkedList implements Collection{

    /**
     * 头结点
     */
    private Node head = null;

    /**
     * 当前大小
     */
    private int size = 0;

    private Node tail = null;

    /**
     * 添加元素
     * @param o
     */
    public void add(Object o){
        Node node = new Node(o,null);
        if(head == null){ //如果头结点为空
            head = node;
            tail = node;
            node.setNext(null);
        }else{
            tail.setNext(node);
            tail = node;
        }
        size++;
    }

    /**
     * 获取长度
     * @return
     */
    public int size(){
        return size;
    }
    public Iterator iterator(){
        return new LinkedListIterator();
    }

    /**
     * 迭代器的内部类实现
     */
    private class LinkedListIterator implements Iterator{

        private Node currentNode = head;

        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            if(currentNode== null){
                return false;
            }
            else return true;
        }


        @Override
        public Object next() {
            Node node = currentNode;
            currentNode = currentNode.getNext();
            return node;
        }
    }
}

4、第四个文件：TestMain.java

/**
 * 测试Main方法
 */
public class TestMain {

    public static void main(String [] args){
        Collection c = new MyLinkedList();
        for(int i=0;i<5;i++){
            Object o = new Object();
            System.out.println("序号：" + i + " 对象：" + o);
            c.add(o);
        }

        Iterator it = c.iterator();
        while(it.hasNext()){
            Node o = (Node) it.next();
            System.out.println(o.getData());
        }
    }
}

好了，以上就是我们对迭代器模式的应用实现，下面总结下迭代器模式的优点：
（1）、封装容器的内部实现细节，简化客户端的访问和获取容器内数据。
（2）、客户端可以通过相同的方式遍历不同的容器对象。
（3）、我们可以根据客户端需求让容器实现不同的迭代算法，从而可以用不同的遍历方式来访问容器数据。