设计模式——迭代器模式

迭代器模式

@author lisiwen

@createTime 2019/12/26

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

迭代器代码示例

Aggregate.java

/**
 * @ProjectName: Aggregate
 * @ClassName: Main
 * @Description: Aggregate聚集接口
 * @Author: lisiwen
 * @Date: 2019/12/26 8:47
 **/
public interface Aggregate {
    /**
     * @Description 创建迭代器
     * @Date 2019/12/26 8:53
     * @param
     * @Return iterator.Iterator
     **/
    Iterator createIterator();
}

ConcreteAggregate.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteAggregate
 * @Description: ConcreteAggregate具体据几类  集成Aggregate
 * @Author: lisiwen
 * @Date: 2019/12/26 8:55
 **/
public class ConcreteAggregate implements Aggregate {

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

    /**
     * @Description 返回聚集总数
     * @Date 2019/12/26 9:02
     * @param
     * @Return int
     **/
    public int count(){
        return items.size();
    }

    /**
     * @Description 索引器
     * @Date 2019/12/26 9:02
     * @param index
     * @Return java.lang.Object
     **/
    public Object getItem(int index) {
        return this.items.get(index);
    }

    public Object setItem( Object value) {
        return this.items.add(value);
    }

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

Iterator.java

/**
 * @ProjectName: Iterator
 * @ClassName: Main
 * @Description: Iterator迭代器接口
 * @Author: lisiwen
 * @Date: 2019/12/26 8:47
 **/
public interface Iterator {
    /**
     * @Description 开始对象
     * @Date 2019/12/26 8:51
     * @param
     * @Return java.lang.Object
     **/
    Object first();
    /**
     * @Description 下一个对象
     * @Date 2019/12/26 8:51
     * @param
     * @Return java.lang.Object
     **/
    Object next();
    /**
     * @Description 判断是否到结尾
     * @Date 2019/12/26 8:51
     * @param
     * @Return boolean
     **/
    boolean isDone();
    /**
     * @Description 当前对象
     * @Date 2019/12/26 8:51
     * @param
     * @Return java.lang.Object
     **/
    Object currentItem();

}

ConcreteIterator.java

/**
 * @ProjectName: designpattern
 * @ClassName: ConcreteIterator
 * @Description: TODO(一句话描述该类的功能)
 * @Author: lisiwen
 * @Date: 2019/12/26 8:54
 **/
public class ConcreteIterator implements Iterator {
    /**
     * 定义一个聚集对象
     */
    private ConcreteAggregate concreteAggregate;
    private int current = 0;

    public ConcreteIterator(ConcreteAggregate concreteAggregate) {
        this.concreteAggregate = concreteAggregate;
    }

    @Override
    public Object first() {
        // 取第一个对象
        return concreteAggregate.getItem(0);
    }

    @Override
    public Object next() {
        Object ret = null;
        current++;
        // 如果没结束则返回下一个对象
        if (current < concreteAggregate.count()) {
            ret = concreteAggregate.getItem(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        //判断是否结束
        return current >= concreteAggregate.count();
    }

    @Override
    public Object currentItem() {
        //返回当前对象
        return concreteAggregate.getItem(current);
    }
}

Main.java

/**
 * @ProjectName: designpattern
 * @ClassName: Main
 * @Description: 客户端代码
 * @Author: lisiwen
 * @Date: 2019/12/26 8:47
 **/
public class Main {
    public static void main(String[] args) {
        ConcreteAggregate a =new ConcreteAggregate();
        a.setItem("A");
        a.setItem("B");
        a.setItem("C");
        a.setItem("D");
        a.setItem("E");
        a.setItem("F");

        Iterator i =new ConcreteIterator(a);
        i.first();
        while(!i.isDone()){
            System.out.println(i.currentItem()+"---");
            i.next();
        }
    }
}
//控制台输出
A---
B---
C---
D---
E---
F---

迭代器用处

当你对聚集有多种方式遍历时，可以考虑使用迭代器模式。

迭代器优点

迭代器(Iterator)模式就是分离了几何对象的便利性为，抽象出一个迭代器类来负责，这样即可以做到不暴露集合的内部结构，又可以让外不带吗透明的访问集合内部的数据。