迭代器模式

迭代器模式的定义：提供一种顺序访问一个聚合对象中各个元素的方法，但是又不会暴露该对象的内部表示。这个内部表示我的理解就是指向集合的指针，因为一般来讲遍历一个集合必须要像游标遍历结果集一样，迭代器模式就是让外界调用集合的createIterator方法来创建一个接口，这个接口暴露的方法和具体集合无关，然后通过这个接口的实现类和具体聚合对象之间的引用，把这个迭代器和具体聚合对象联系起来。

package com.jerry.design.iterator;

import java.util.ArrayList;
import java.util.List;


	// 测试类
public class Test {

	public static void main(String[] args) {
		
		String[] s = {"测试一","测试二","测试三","测试四"};
		
		Aggregate a = new ConcreteAggregate(s);
		
		Iterator it = a.createIterator();
		
		it.first();
		
		while(it.hasNext()){
			System.out.println(it.current());
			it.next();
		}
	}
}
interface Iterator{
	 public void first();
	 public void next();
	 public boolean hasNext();
	 public Object current();
}

class ConcreteIterator implements Iterator{

	private int index = -1;
	private ConcreteAggregate aggregate;
	
	
	
	public ConcreteIterator(ConcreteAggregate aggregate) {
		super();
		this.aggregate = aggregate;
	}

	@Override
	public void first() {
		index = 0;
	}

	@Override
	public void next() {
		if(index<aggregate.size()){
			index++;
		}
		
	}

	@Override
	public boolean hasNext() {
		int temp = index;
		if(temp<aggregate.size()){
			return true;
		}
		return false;
	}

	@Override
	public Object current() {
		return aggregate.get(index);
	}

	
	
}
interface Aggregate{
	 public abstract  Iterator createIterator();
}

class ConcreteAggregate implements Aggregate{
	
	private String[] s = null;

	
	
	public ConcreteAggregate(String[] s) {
		super();
		this.s = s;
	}



	@Override
	public Iterator createIterator() {
		return new ConcreteIterator(this);
	}

	public Object get(int index){
		if(index<s.length){
			return s[index];
		}else{
			return null;
		}
	}
	
	public int size(){
		return s.length;
	}
}