迭代器模式

迭代器模式(Iterator pattern)

结构

1：聚合对象，存储数据

2：迭代器，遍历数据

案例（自定义迭代器）

自定义迭代器接口

/*
 * 自定义的迭代器接口
 */
public interface MyIterator {
	void first();  //将游标指向第一个元素
	void next();	//将游标指向下一个元素
	boolean hasNext();  //判断是否存在下一个元素
	boolean isFirst();
	boolean isLast();
	Object getCurrentObj(); //获取当前游标指向的对象
}

聚合对象

/*
 * 自定义聚合类
 */
public class ConcreteAggregate {
	private List<Object> list = new ArrayList<Object>();
	
	public void addObject(Object obj){
		this.list.add(obj);
	}
	
	public void removeObject(Object obj){
		this.list.remove(obj);
	}
	
	public List<Object> getList(){
		return list;
	}
	
	public void setList(List<Object> list){
		this.list = list;
	}
	
	//获得迭代器
	public MyIterator creareIterator(){
		return new ConcreterIterator();
	}
	
	/*
	 * 定义一个内部类，实现迭代器接口,内部类可以直接访问外部类成员变量
	 */
	private class ConcreterIterator implements MyIterator{
		private int cursor; //定义游标用于记录遍历时的位置
		@Override
		public void first() {
			cursor = 0;
		}

		@Override
		public void next() {
			if(cursor < list.size()){
				cursor++;
			}
		}

		@Override
		public boolean hasNext() {
			if(cursor < list.size()){
				return true;
			}
			return false;
		}

		@Override
		public boolean isFirst() {
			return cursor == 0;
		}

		@Override
		public boolean isLast() {
			return cursor == list.size();
		}

		@Override
		public Object getCurrentObj() {
			return list.get(cursor);
		}
		
	}
}

客户端测试

public class Client {
	public static void main(String[] args) {
		ConcreteAggregate ca = new ConcreteAggregate();
		ca.addObject("mark");
		ca.addObject("jek");
		ca.addObject("keys");
		
		//获取自己定义的迭代器
		MyIterator iterator = ca.creareIterator();
		while(iterator.hasNext()){
			System.out.println(iterator.getCurrentObj());
			iterator.next();
		}
	}
}

console:
mark
jek
keys