迭代器模式(Iterator)

一.迭代器模式定义

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示

二.迭代器模式结构说明

1.Iterator：迭代器接口。定义访问和遍历元素的统一接口。

2.ConcreteIterator：具体的迭代器实现对象。实现对聚合对象的遍历，并跟踪当前位置。

3.Collection：集合。迭代器的遍历目标。

4.ConcreteCollection：具体的集合对象。

三.迭代器模式示例代码

package com.exercise.util;

import com.exercise.util.Collection;

//提供一种统一的接口，所有需要遍历的容器必须实现这两个方法
public interface MyIterator {
	boolean hasNext();
	Object next();
}

package com.exercise.util;

//集合
public interface Collection {
	void add(Object obj);
	int size();
	MyIterator iterator();
	
}

四.简单模拟jdk迭代器模式遍历

/**
 * @function 写一个自己的collections，能够往里面添加东西
 * 
 */
package com.exercise.util;

import com.exercise.util.Collection;
public class MyArrayList implements Collection{
	private int size=10;
	
	private Object [] array=null;
	
	public MyArrayList(){
		array=new Object[2];//可以容纳两个元素
	}
	
	public void add(Object obj){
		array[size]=obj;
		size++;
		Object [] tempArray=new Object[getTempSize()];
//		System.out.println("临时大小:"+getTempSize());
		//将原来的数据复制到这个新的数组中
		copy(tempArray,array);
		array=tempArray;
	}
	
	//将老数组里面的东西copy到新数组里面去
	private void copy(Object[] newArray, Object[] oldArray) {
		for(int i=0;i<oldArray.length;i++){
			if(oldArray[i]!=null){
				newArray[i]=oldArray[i];				
			}
		}
	}
	
	//打印数组
	public void show(){
		for(int i=0;i<array.length;i++){
			if(array[i]!=null){
				System.out.print(array[i].toString()+"\t");				
			}
		}
		System.out.println ();
	}
	//数组大小
	public int size(){
		return size;
	}
	private int getTempSize(){
		return size+10;
	}

	@Override
	public MyIterator iterator() {
		return new ArrayListIterator();
	}

	//内部类，为了访问当前集合中的数据，迭代器遍历元素使用内部类是最好的实现方式(jdk源码中也使用的是内部类)
	private class ArrayListIterator implements MyIterator{
		private int listIndex=0;
		
		@Override
		public boolean hasNext() {
			if(listIndex<size) return true;
			else return false;
		}

		@Override
		public Object next() {
			Object obj=array[listIndex];
			listIndex++;
			return obj;
		}

	}
}

package com.exercise.util;

//节点
public class Node {
	private Object element=null;
	private Node nextNode=null;
	
	public Object getElement() {
		return element;
	}
	public void setElement(Object element) {
		this.element = element;
	}
	public Node getNextNode() {
		return nextNode;
	}
	public void setNextNode(Node nextNode) {
		this.nextNode = nextNode;
	}
	
	@Override
	public String toString(){
		return this.getElement().toString();
	}
	
}

package com.exercise.util;

import com.exercise.util.Collection;
public class MyLinkedList implements Collection{
	private int size=0;
	
	private Node[] nodeList=null;
	//第一个元素
	private Node firstNode=null;
	
	public MyLinkedList(){
		nodeList=new Node[10];
	}
	
	public void add(Object obj){
		if(obj==null){
			try {
				throw new Exception("添加的元素不能为空！");
			} catch (Exception e) {
				e.printStackTrace();
			}
			return ;
		}
		//如果容量不够了
		if(size==nodeList.length){
			Node []tempNodeList=new Node[getIncreasedSize()];
			System.arraycopy(nodeList, 0, tempNodeList, 0, nodeList.length);			
			nodeList=tempNodeList;
		}
		//开始添加节点了
		Node tempNode=new Node();
		if(size==0){//第一个元素
			firstNode=tempNode;
			tempNode.setElement(obj);
			tempNode.setNextNode(firstNode);
			nodeList[size]=firstNode;
		}else{
			nodeList[size-1].setNextNode(tempNode);
			tempNode.setElement(obj);
			tempNode.setNextNode(firstNode);
			nodeList[size]=tempNode;
		}		
	    size++;
	}
	
	private int getIncreasedSize(){
		return size+10;
	}
	//遍历元素
	public void show(){
		if(size==1){
			System.out.println(firstNode.getElement());
		}else{
			System.out.print(firstNode.getElement()+"\t");
			Node node=firstNode.getNextNode();
			while(node!=firstNode){
				System.out.print(node.getElement()+"\t");
				node=node.getNextNode();
			}
		}
		System.out.println();
	}

	public int size() {
		return size;
	}

	@Override
	public MyIterator iterator() {
		return new LinkedListIterator();
	}
	
	//为了方便访问LinkedList中的数据，写一个遍历的临时内部类
	private class LinkedListIterator implements MyIterator{
		private int listIndex=0;
		private Node tempNode=firstNode;
		
		@Override
		public boolean hasNext() {
			if(tempNode==null){//第一个为空
				return false;
			}else{
				if(tempNode.getNextNode()!=firstNode) return true;
				else return false;
			}
		}

		@Override
		public Object next() {
			if(listIndex==0){
				listIndex++;
				return tempNode;
			}else{
				tempNode=tempNode.getNextNode();
				listIndex++;
				return tempNode;
			}
		}
		
	}	

}

package com.exercise.test;

import com.exercise.util.MyArrayList;
import com.exercise.util.MyIterator;
import com.exercise.util.MyLinkedList;
import com.exercise.util.Node;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		MyArrayList arr=new MyArrayList();
//		arr.add("hello");
//		arr.add("world");
//		arr.add("你好");
//		arr.add("你好");
//		arr.add("!!!");
//		arr.show();
//		System.out.println("数组大小："+arr.size());
		
		MyLinkedList arr=new MyLinkedList();
		for(int i=0;i<6;i++){
			arr.add("Hello");
			arr.add("World");			
		}
//		arr.show();
		System.out.println("链表大小："+arr.size());
		
		//统一遍历接口
		MyIterator iter=arr.iterator();
		while(iter.hasNext()){
			System.out.print(iter.next()+"\t");
		}
	}

}

输出结果：
1.MyArrayList类测试结果：数组大小：5     helloworld你好你好 !!!
2.MyLinkedList类测试结果：链表大小：12    HelloWorldHelloWorldHelloWorldHelloWorldHelloWorldHelloWorld