Java 23种设计模式之迭代器模式

1. 概念

提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。

2. 创建迭代器接口类

/**
 * @author zlc
 * @created 2017/12/24
 * 迭代器接口类
 */
public interface  Iterator {

     Object first();

     Object last();

     Object next();

     boolean hasNext();

     Object getCurrentItem();
}

3. 创建具体迭代器实现类

/**
 * @author zlc
 * @created 2017/12/24
 * 迭代器实现类
 */
public class ConcreteIterator implements Iterator{

    private ConcreteAggregate aggregate;
    private int current;
    public ConcreteIterator(ConcreteAggregate aggregate){
        this.aggregate = aggregate;
    }

    @Override
    public Object first() {
        return aggregate.getItem(0);
    }

    @Override
    public Object last() {
        return aggregate.getItem(aggregate.length() - 1);
    }

    @Override
    public Object next() {
        Object obj = null;
        current++;
        if(current < aggregate.length()){
            obj = aggregate.getItem(current);
        }
        return obj;
    }

    @Override
    public boolean hasNext() {

        return current < aggregate.length();
    }

    @Override
    public Object getCurrentItem() {
        return aggregate.getItem(current);
    }
}

4. 创建聚集抽象类

/**
 * @author zlc
 * @created 2017/12/24
 * 聚集抽象类
 */
public abstract class Aggregate {

    //获取迭代器对象
    public abstract Iterator iterator();
}

5. 创建聚集抽象实现类

/**
 * @author zlc
 * @created 2017/12/24
 * 具体聚集类
 */
public class ConcreteAggregate extends Aggregate{

    private Object[] items = new Object[]{};

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

    public void setItems(Object[] items) {
        this.items = items;
    }

    public Object getItem(int index){
        return items[index];
    }

    public void setItem(int index,Object obj){
        items[index] = obj;
    }

    public int length(){
        return items.length;
    }
}

6. 测试类

@org.junit.Test
public void test(){

    ConcreteAggregate ca = new ConcreteAggregate();
    String[] obj = {
            "zlc","cc","zq","yjy","xiaocheng","xiaoyu"
    };
    ca.setItems(obj);

    Iterator it = new ConcreteIterator(ca);
    Object first = it.first();
    Object last = it.last();
    System.out.println(first+" 请买车票");
    System.out.println(last+" 请买车票");
    System.out.println("------------");

    while (it.hasNext()){
        System.out.println(it.getCurrentItem()+" 请买车票");
        it.next();
    }

}     

7.小结

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