Java模拟容器的迭代器(Iterator模式)

　　　Iterator模式提供一系列的方法用于遍历某一类聚合对象的各个元素，在此，通过模拟容器的迭代器来学习Iterator模式。

         首先，模拟实现JAVA中用得最多的ArrayList和LinkedList，当然这2类容器都是实现Collection接口的，为什么要实现Collection接口？最根本的原因肯定是多态。

        

/**
 * 
 * @author LingJian
 *
 */
public class ArrayList implements Collection {
    private Object[] objects = new Object[10];
    private int index = 0;
    
    public void add(Object o) {
        if(index == objects.length) {
            Object[] newObjects = new Object[objects.length * 2];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }
        objects[index] = o;
        index ++;
    };
    
    public int size() {
        return index;
    };
}

public class LinkedList implements Collection {
    //头
    private Node head = null;
    //尾
    private Node tail = null;
    private int index = 0;
    
    public void add(Object o) {
        Node n = new Node(o,null);
        if(head == null) {
            head = n;
            tail = n;
        }
        tail.setNext(n);
        tail = n;
        index ++;
    }
    
    public int size() {
        return index;
    }
}

public class Node {
    private Object data;
    private Node 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;
    }
    public Node(Object data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }
}

/**
 * 
 * @author LingJian
 *
 */
public interface Collection {
    public void add(Object o);
    public int size();
}

/**
 * 
 * @author LingJian
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection c = new LinkedList();
        for(int i=0; i<15; i++) {
            c.add(new Cat(i));
        };
        System.out.println(c.size());
        
                
    }

}

/**
 * 
 * @author LingJian
 *
 */
public class Cat {
    private int id;

    public Cat(int id) {
        super();
        this.id = id;
    }

    /**
     * 方便打印查看
     */
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "cat:" + id;
    }
}

　　　OK，如果不想用ArrayList，可以轻松切换LinkedList就能换一个容器，这就是多态给我们带来的好处。

         现在，容器能容纳东西，那如果要取出来呢？

        

/**
 * 
 * @author LingJian
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection c = new ArrayList();
        for(int i=0; i<15; i++) {
            c.add(new Cat(i));
        };
        System.out.println(c.size());
        
        ArrayList al = (ArrayList) c;
        for(int i=0; i<al.size();i++) {
            .....
        }
                    }
}

　　   是的，这样写完全没有错，但是如果这时候发现容器换成了LinkedList，这段代码就需要全部替换了，因为LinkedList内部结构的实现是链表，遍历的方式不一样了，所以我们需要设计出一种可以不关注聚合对象内部元素结构的方法，不管是遍历什么容器，都能使用，无须更改方法。OK，Iterator模式就是为了解决这一一类问题而出现的，在这主要写LinkedList的Iterator。

        

/**
 * 
 * @author LingJian
 *
 */
public interface Iterator {
    Object next();
    boolean hasNext();
}

/**
 * 
 * @author LingJian
 *
 */
public class LinkedList implements Collection {
    //头
    private Node head = null;
    //尾
    private Node tail = null;
    private int index = 0;
    
    public void add(Object o) {
        Node n = new Node(o,null);
        if(head == null) {
            head = n;
            tail = n;
        }
        tail.setNext(n);
        tail = n;
        index ++;
    }
    
    public int size() {
        return index;
    }

    @Override
    public Iterator iterator() {
        return new LinkedListIterator();
    }
    
    public class LinkedListIterator implements Iterator {
        
        @Override
        public Object next() {
            Object o = head.getData();
            head = head.getNext();
            return o;
        }

        @Override
        public boolean hasNext() {
            if(head == null) return false;
            else return true;
        }
        
    }
}

/**
 * 
 * @author LingJian
 *
 */
public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Collection c = new LinkedList();
        for(int i=0; i<15; i++) {
            c.add(new Cat(i));
        };
        System.out.println(c.size());
        
        
        
        Iterator it = c.iterator();
        while(it.hasNext()) {
            Object o =     it.next();
            System.out.print(o + " ");
        }
        
    }

}

         有了Iterator，遍历的聚合对象只要对外提供了自己符合要求的Iterator，这段遍历的方法便可重复使用，完全不需要关注元素的内部结构。

         Iterator模式主要用于遍历，所以相对来说比较简单。