面向对象编程思想中，多态是一个最重要的特性，代码灵活性的体现主要是靠这种思想来实现的。现在模拟Sun公司当中的两个集合类LinkedList和ArrayList。这些具体的容器，都可以用一个Collection的接口来接收。最常用的就是遍历容器，而现在不同的容器，遍历它们的具体实现是不同的，而我们可以将遍历的方法封装到一个接口Iterator当中，在这个接口当中实现hasNext()和next()的方法，再由具体的容器去实现它。而作为用户，只需要知道这个容器当中的两个方法就行了，具体的遍历实现，由不同的容器自身给出。
1 package programe.iterator.model; 2 3 public interface Collection { 4 public void add(Object o); 5 public int size(); 6 public Iterator iterator(); 7 } 8 9 10 public interface Iterator { 11 public Object next(); 12 public boolean hasNext(); 13 }
1、ArrayList容器的实现
1 package programe.iterator.model; 2 3 public class ArrayList implements Collection{ 4 Object[] objects=new Object[10]; 5 int index=0; 6 @Override 7 public void add(Object o) { 8 if(index==objects.length) { 9 Object[]newObjects=new Object[objects.length*2]; 10 System.arraycopy(objects,0,newObjects,0,objects.length); 11 objects=newObjects; 12 } 13 objects[index]=o; 14 index++; 15 } 16 17 @Override 18 public Iterator iterator() { 19 return new ArrayListIterator(); 20 } 21 22 @Override 23 public int size() { 24 return index; 25 } 26 27 private class ArrayListIterator implements Iterator { 28 private int currentIndex=0; 29 @Override 30 public boolean hasNext() { 31 if(currentIndex>=index) { 32 return false; 33 } 34 return true; 35 } 36 37 @Override 38 public Object next() { 39 Object o=objects[currentIndex]; 40 currentIndex++; 41 return o; 42 } 43 44 } 45 }
2、LinkedList容器实现
1 package programe.iterator.model; 2 3 public class Node { 4 5 private Object data; 6 private Node next; 7 public Node(Object data,Node next) { 8 this.data=data; 9 this.next=next; 10 } 11 public Object getData() { 12 return data; 13 } 14 public void setData(Object data) { 15 this.data = data; 16 } 17 public Node getNext() { 18 return next; 19 } 20 public void setNext(Node next) { 21 this.next = next; 22 } 23 24 } 25 26 27 public class LinkedList implements Collection{ 28 29 Node head=null; 30 Node tail=null; 31 int size=0; 32 @Override 33 public void add(Object o) { 34 Node n=new Node(o,null); 35 if(head==null) { 36 head=n; 37 tail=n; 38 size=1; 39 return; 40 } 41 tail.setNext(n); 42 tail=n; 43 size++; 44 } 45 46 @Override 47 public Iterator iterator() { 48 return new LinkedListIterator(); 49 } 50 51 @Override 52 public int size() { 53 return size; 54 } 55 56 private class LinkedListIterator implements Iterator { 57 Node currentNode=head; 58 @Override 59 public boolean hasNext() { 60 if(currentNode.getNext()==null) { 61 return false; 62 } 63 return true; 64 } 65 66 @Override 67 public Object next() { 68 if(currentNode==head) { 69 currentNode=currentNode.getNext(); 70 return head; 71 } 72 73 Node next=currentNode.getNext(); 74 currentNode=next; 75 return next; 76 } 77 } 78 }
测试代码：
1 public class Main { 2 public static void main(String[]args) { 3 //Collection c=new ArrayList(); 4 Collection c=new LinkedList(); 5 for(int i=0;i<15;i++) { 6 c.add(i); 7 } 8 System.out.println(c.size()); 9 10 Iterator iter=c.iterator(); 11 while(iter.hasNext()) { 12 System.out.println(((Node)iter.next()).getData()); 13 } 14 } 15 }
评论：LinkedList容器是基于链表的；ArrayList容器是基于数组的。它们的构造不同，因此遍历方式也不同，如果不提供Iterator这样一个公共方法的接口给用户。那么用户需要记住每一种容器的遍历方法，而现在用户只需记住Iterator接口当中提供的方法即可。这里面的方法适合遍历实现了Iterator接口的容器。遍历只是一个容器具有的方法，不能说将所有的容器都去实现这个方法的接口，因此这里还提供了一个Collection接口，所有容器的接口，而Iterator这个接口仅仅只是Collection接口当中提供的一个方法。因为，各种具体容器除了遍历之外，肯定还有其他的公共需求，这时，一个Collection就可以将具体容器的实现暴露给用户，极大的方便了编程。
原文：http://www.cnblogs.com/feijishuo/p/3705275.html