迭代器模式Iterators

迭代器模式:提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。 

选用场合：

1.访问一个聚合对象的内容而无需暴露它的内部表示。
2.支持对聚合对象的多种遍历。
3.为遍历不同的聚合结构提供一个统一的接口(即，多态迭代)。

迭代器模式由以下角色组成：

1)迭代器角色(Iterator)：迭代器角色负责定义访问和遍历元素的接口。

2)具体迭代器角色(Concrete Iterator)：具体迭代器角色要实现迭代器接口，并要记录遍历中的当前位置。

3)容器角色(Container)：容器角色负责提供创建具体迭代器角色的接口。

4)具体容器角色(Concrete Container)：具体容器角色实现创建具体迭代器角色的接口??这个具体迭代器角色于该容器的结构相关。

package com.qinsoft.design;

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

/**
 * Iterators：行为型
 */
public class Iterators {
    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);
        
        // 迭代器第一个对象（从第一个乘客开始)
        while(!i.isDone()){
            System.out.println(i.currentItem()+"请买车票");
            i.next();
        }
        System.out.println("------------反向遍历---------------");
        
        //-----反向遍历-------------------
        Iterator iDesc = new ConcreteIteratorDesc(a);
        // 迭代器第一个对象（从最后一个乘客开始)
        while(!iDesc.isDone()){
            System.out.println(iDesc.currentItem()+"请买车票");
            iDesc.next();
        }
    }
}
/**
 * 聚集抽象类
 */
abstract class Aggregate {
    // 创建迭代器
    public abstract Iterator createIteraotr();

}
/**
 * 具体的聚集类，继承聚集抽象类Aggregate
 */
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;
    }
}
/**
 * 迭代器抽象类
 */
abstract class Iterator {
    
    // 开始对象
    public abstract Object first();
    // 下一个对象
    public abstract Object next();
    // 当前对象
    public abstract Object currentItem();
    // 是否到结尾
    public abstract boolean isDone();
}
/**
 * 具体的迭代器类，继承迭代器抽象类Iterator
 */
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;
    }
}
/**
 * 反向遍历的具体的迭代器类，继承迭代器抽象类Iterator
 */
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;
    }
}