《大话设计模式--迭代器模式》笔记

小鱼儿 2022-04-14 07:12 242阅读 0赞

1、迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象内部表示。

2、当你访问一个聚合对象，而且不管对象是什么都需要遍历的时候，你就应该考虑使用迭代器模式。  
当你需要对聚集有多种方式遍历的时候，可以考虑室友迭代器模式。

3、目前迭代器模式的实用价值已经远不如学习价值了。

4、迭代器模式结构图，  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzkwODMz_size_16_color_FFFFFF_t_70]

5、Iterator迭代器类

public abstract class Iterator {
    	
    	//得到开始对象
    	public abstract Object first();
    	//得到下一个对象
    	public abstract Object next();
    	//判断是否结尾
    	public abstract boolean isDone();
    	//当前对象
    	public abstract Object CurrentItem();
    	
    
    }

aggregate聚集抽象类

public abstract class Aggregate {
    
    	//创建抽象类
    	public abstract Iterator createIterator();
    }

ConcreteIterator具体迭代器类，继承Iterator

public class ConcreteIterator extends Iterator {
    
    	//定义了一个具体聚集对象
    	private ConcreteAggregate aggregate;
    	private int current=0;
    	
    	public ConcreteIterator(ConcreteAggregate aggregate) {
    		// TODO Auto-generated constructor stub
    		this.aggregate=aggregate;
    	}
    	
    	@Override
    	public Object first() {
    		// TODO Auto-generated method stub
    		return aggregate.get(0);
    	}
    
    	@Override
    	public Object next() {
    		// TODO Auto-generated method stub
    		Object ret=null;
    		current++;
    		
    		if(current<aggregate.count()) {
    			ret=aggregate.get(current);
    		}
    		return ret;
    	}
    
    	@Override
    	public boolean isDone() {
    		// TODO Auto-generated method stub
    		return current>=aggregate.count()? true:false;
    	}
    
    	@Override
    	public Object CurrentItem() {
    		// TODO Auto-generated method stub
    		return aggregate.get(current);
    	}
    
    }

ConcreteAggregate具体聚集类

public class ConcreteAggregate extends Aggregate{
    	
    	private List<Object> items=new ArrayList<Object>();
    
    	@Override
    	public Iterator createIterator() {
    		// TODO Auto-generated method stub
    		return new ConcreteIterator(this);
    	}
    	
    
    	public int count() {
    		return items.size();
    	}
    	
    	
       public Object get(int index){
    	   
    	   return items.get(index);
    	   
       }
    	
    
       public void set(int index,Object value){
    	   
    	    items.add(index, value);
       }
    	
    }

客户端代码：

public class Client {
    	
    	public static void main(String[] args) {
    		ConcreteAggregate a=new ConcreteAggregate();
    		
    		a.set(0, "大鸟");
    		a.set(1, "小明");
    		a.set(2, "小王");
    		a.set(3, "老外");
    		a.set(4, "内部员工");
    		a.set(5, "小偷");
    		
    		Iterator i=new ConcreteIterator(a);
    		
    		Object item=i.first();
    		
    		while(!i.isDone()) {
    			System.out.println(i.CurrentItem()+"请买票");
    			i.next();
    		}
    		
    		
    	}
    
    }

6、总结  
迭代器：模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样做既可以不暴露集合的内部结构，又可以让外部代码透明的访问集合内部数据。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNzkwODMz_size_16_color_FFFFFF_t_70]: /images/20220414/965e6996c66f40a8ad3d84d611d59723.png