java设计模式-Iterator
Iterator模式
主要是用在容器的遍历上，其他的地方都不怎么用；理解一下，会用了就可以了；
1、背景
请动手自己写一个可以动态添加对象的容器；
代码：
ArrayList.java（是自己实现的，不是JDK）
package com.cy.dp.iterator; public class ArrayList { Object[] objects = new Object[10]; int index = 0; //objects下一个空的位置 /** * 如果数组容量已满，这里简单处理，扩容为原来的两倍； * sun的做法是有一个加权值，根据原来的容量，加上多少... * @param o */ 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; } }
Cat.java 辅助类：
package com.cy.dp.iterator; public class Cat { private int id; public Cat(int id) { super(); this.id = id; } }
Test.java 测试类：
package com.cy.dp.iterator; import com.cy.dp.iterator.ArrayList; public class Test { public static void main(String[] args) { ArrayList al = new ArrayList(); for(int i=0; i<15; i++){ al.add(new Cat(i)); } System.out.println(al.size()); } }
2.上面容器的底层实现是用数组，下面使用链表来做个容器；
简单解释链表：
每一个链表里面装的都是一个一个的节点，每个节点里面包括两部分内容：1.数据本身 2.指向下一个节点的一个引用；
代码：
Node.java:
package com.cy.dp.iterator; 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; } }
LinkedList.java:
package com.cy.dp.iterator; public class LinkedList { Node head = null; Node tail = null; //最末尾的节点 int size = 0; //记录当前链表里面Node个数 public void add(Object o){ Node n = new Node(o, null); if(head==null){ head = n; tail = n; } tail.setNext(n); tail = n; size++; } public int size(){ return size; } }
Test.java 测试类：
package com.cy.dp.iterator; import com.cy.dp.iterator.ArrayList; import com.cy.dp.iterator.LinkedList; public class Test { public static void main(String[] args) { //ArrayList al = new ArrayList(); LinkedList al = new LinkedList(); for(int i=0; i<15; i++){ al.add(new Cat(i)); } System.out.println(al.size()); } }
3.考虑容器的可替换性
Test类中的容器类可以替换，但是测试方法无须修改；比如LinkedList里面添加元素方法为addObject()的话，那么代码就要重新修改了；
所以有必要对ArrayList和LinkedList对外公开的方法统一起来；
使用接口Collection，面向接口编程；好处是灵活，可扩展；
于是就变成了代码：
Collection.java：
package com.cy.dp.iterator; public interface Collection { void add(Object o); int size(); }
ArrayList.java (实现Collection接口)
package com.cy.dp.iterator; import com.cy.dp.iterator.Collection; public class ArrayList implements Collection { Object[] objects = new Object[10]; int index = 0; //objects下一个空的位置 /** * 如果数组容量已满，这里简单处理，扩容为原来的两倍； * sun的做法是有一个加权值，根据原来的容量，加上多少... * @param o */ 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; } }
LinkedList.java(实现Collection接口)
package com.cy.dp.iterator; import com.cy.dp.iterator.Collection; public class LinkedList implements Collection { Node head = null; Node tail = null; //最末尾的节点 int size = 0; //记录当前链表里面Node个数 public void add(Object o){ Node n = new Node(o, null); if(head==null){ head = n; tail = n; } tail.setNext(n); tail = n; size++; } public int size(){ return size; } }
Test.java测试类：
public class Test { 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()); } }
4.容器的遍历
因为上面ArrayList的遍历方式和LinkedList的遍历方式不同，遍历方式不统一的话，实现方式一变，代码就得跟着变；
每一种容器都有自己的遍历方式，那么能不能找到一种统一的遍历方式呢？
代码：
Iterator接口：
package com.cy.dp.iterator; public interface Iterator { Object next(); boolean hasNext(); }
Collection接口：
package com.cy.dp.iterator; public interface Collection { void add(Object o); int size(); Iterator iterator(); }
ArrayList.java:
package com.cy.dp.iterator; import com.cy.dp.iterator.Collection; public class ArrayList implements Collection { Object[] objects = new Object[10]; int index = 0; //objects下一个空的位置 /** * 如果数组容量已满，这里简单处理，扩容为原来的两倍； * sun的做法是有一个加权值，根据原来的容量，加上多少... * @param o */ @Override 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++; } @Override public int size(){ return index; } @Override public Iterator iterator(){ return new ArrayListIterator(); } private class ArrayListIterator implements Iterator{ private int currentIndex = 0; @Override public Object next() { Object o = objects[currentIndex]; currentIndex++; return o; } @Override public boolean hasNext() { if(currentIndex >= index) return false; else return true; } } }
LinkedList.java:
package com.cy.dp.iterator; import com.cy.dp.iterator.Collection; public class LinkedList implements Collection { Node head = null; Node tail = null; //最末尾的节点 int size = 0; //记录当前链表里面Node个数 @Override public void add(Object o){ Node n = new Node(o, null); if(head==null){ head = n; tail = n; } tail.setNext(n); tail = n; size++; } @Override public int size(){ return size; } //返回一个实现了Iterator接口的匿名类 @Override public Iterator iterator(){ return new Iterator(){ Node currentNode = head; @Override public Object next() { Object o = currentNode.getData(); currentNode = currentNode.getNext(); return o; } @Override public boolean hasNext() { if(currentNode==null) return false; else return true; } }; } }
Test.java 测试类：
public class Test { public static void main(String[] args) { Collection c = new LinkedList(); //Collection c = new ArrayList(); for(int i=0; i<15; i++){ c.add(new Cat(i)); } System.out.println(c.size()); Iterator it = c.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } }
打印：
15 Cat [id=0] Cat [id=1] Cat [id=2] Cat [id=3] Cat [id=4] Cat [id=5] Cat [id=6] Cat [id=7] Cat [id=8] Cat [id=9] Cat [id=10] Cat [id=11] Cat [id=12] Cat [id=13] Cat [id=14]
