迭代器模式

迭代器模式:

在软件构建过程中，集合对象内部结构常常变化各异(比如各种不同的集合对象list,set,map)。但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素;在面向对象技术中，将这种遍历机制抽象为“迭代器对象”，它为“应对变化中的集合对象”提供了一种优雅的方法。

 

适用性：

1．访问一个聚合对象的内容而无需暴露它的内部表示。

2．支持对聚合对象的多种遍历。

3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

 

 

 

/** 

 * 聚集抽象类 

 */  

public abstract class Aggregate {  

 

    // 创建迭代器  

    public abstract Iterator createIteraotr();  

 

}  

 

Java代码  

/** 

 * 具体的聚集类，继承聚集抽象类Aggregate 

 */  

public class ConcreteAggregate extends Aggregate{  

 

    // 声明一个List泛型变量，用于存放聚合对象  

    private List<Object> items = new ArrayList<Object>();  

    @Override  

    public Iterator createIteraotr() {        

        return new ConcreteIterator(this);  

    }  

    // 返回集合总个数  

    public int count(){  

        return items.size();  

    }  

    public List<Object> getItems() {  

        return items;  

    }  

    public void setItems(List<Object> items) {  

        this.items = items;  

    }  

}  

 

Java代码  

/** 

 * 迭代器抽象类 

 */  

public abstract class Iterator {  

 

    // 开始对象  

    public abstract Object first();  

    // 下一个对象  

    public abstract Object next();  

    // 当前对象  

    public abstract Object currentItem();  

    // 是否到结尾  

    public abstract boolean isDone();  

}  

 

Java代码  

/** 

 * 具体的迭代器类，继承迭代器抽象类Iterator 

 */  

public class ConcreteIterator extends Iterator{  

 

    // 定义一个具体的聚集对象  

    private ConcreteAggregate aggregate;  

    private int current =0 ;  

 

    // 初始化时将具体的聚集对象传入  

    public ConcreteIterator(ConcreteAggregate aggregate){  

        this.aggregate =aggregate;  

    }  

 

    @Override  

    public Object currentItem() {  

        // 返回当前的聚集对象  

        return aggregate.getItems().get(current);  

    }  

 

    @Override  

    public Object first() {  

        // 得到聚集的第一个对象  

        return aggregate.getItems().get(0);  

    }  

 

    @Override  

    public boolean isDone() {  

        // 判断当前是否遍历到结尾，到结尾返回true  

        return current>=aggregate.count()?true:false;  

    }  

 

    @Override  

    public Object next() {  

 

        // 得到聚集的下一个对象  

        Object ref = null;  

        current++;  

        if(current<aggregate.count()){  

            ref = aggregate.getItems().get(current);  

        }  

        return ref;  

    }  

}  

 

Java代码  

/** 

 * 反向遍历的具体的迭代器类，继承迭代器抽象类Iterator 

 */  

public class ConcreteIteratorDesc extends Iterator{  

 

    // 定义一个具体的聚集对象  

    private ConcreteAggregate aggregate;  

    private int current =0 ;  

 

    // 初始化时将具体的聚集对象传入  

    public ConcreteIteratorDesc(ConcreteAggregate aggregate){  

        this.aggregate =aggregate;  

        current = aggregate.count()-1;  

    }  

 

    @Override  

    public Object currentItem() {  

        // 返回当前的聚集对象  

        return aggregate.getItems().get(current);  

    }  

 

    @Override  

    public Object first() {  

        // 得到聚集的第一个对象  

        return aggregate.getItems().get(aggregate.count()-1);  

    }  

 

    @Override  

    public boolean isDone() {  

        // 判断当前是否遍历到结尾，到结尾返回true  

        return current<0?true:false;  

    }  

 

    @Override  

    public Object next() {  

 

        // 得到聚集的下一个对象  

        Object ref = null;  

        current--;  

        if(current>=0){  

            ref = aggregate.getItems().get(current);  

        }  

        return ref;  

    }  

}  

 

Java代码  

public class Main {  

 

    public static void main(String[] args) {  

 

        // 聚集对象（公交车）  

        ConcreteAggregate a = new ConcreteAggregate();  

 

        // 对象集合（新上来的乘客)  

        List<Object> items = new ArrayList<Object>();  

        items.add("大鸟");  

        items.add("小菜");  

        items.add("行李");  

        items.add("老外");  

        items.add("公交内部员工");  

        items.add("小偷");          

        a.setItems(items);  

 

        // 迭代器对象  

        Iterator i = new ConcreteIterator(a);  

 

        // 迭代器第一个对象（从第一个乘客开始)  

        Object item = i.first();  

        while(!i.isDone()){  

            System.out.println(i.currentItem()+"请买车票");  

            i.next();  

        }  

        System.out.println("------------反向遍历---------------");  

 

        //-----反向遍历-------------------  

        Iterator iDesc = new ConcreteIteratorDesc(a);  

        // 迭代器第一个对象（从最后一个乘客开始)  

        Object item2 = iDesc.first();  

        while(!iDesc.isDone()){  

            System.out.println(iDesc.currentItem()+"请买车票");  

            iDesc.next();  

        }  

    }  

}