迭代器模式

定义

提供一个对象来顺序访问聚合对象中的所有数据，不暴露聚合对象的内部表示

架构

抽象聚合：定义操作【存储、添加、删除】聚合对象以及创建迭代器对象
具体聚合：返回一个具体的迭代器；
抽象迭代器：定义访问和遍历聚合元素的接口，通常包含hasNext()、first()、next() 等方法；
具体迭代器：完成对聚合对象的遍历，记录遍历的当前位置

应用场景

1、对一组元素提供多种遍历方式
2、遍历不同组提供的一个统一接口
3、访问一组元素中的一个对象的内容而无需暴露内部细节

代码

Aggregate（抽象聚合）

/**
 * 抽象聚合
 * */
public interface Aggregate {

    void add(Object o);

    void remove(Object o);

    Iterator getIterator();

}

ConcreteAggregate（具体聚合）

/**
 *
 * Description:
 *          具体聚合
 * @author: mushi
 * @Date: 2021/2/22 14:47
 */
public class ConcreteAggregate implements Aggregate{

    //链表可以换成自定义的
    private List list = new ArrayList();

    @Override
    public void add(Object o) {
        list.add(o);
    }

    @Override
    public void remove(Object o) {
        list.remove(o);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
}

ConcreteIterator（具体迭代器）

/**
 *
 * Description:
 *      具体迭代器
 * @author: mushi
 * @Date: 2021/2/22 14:49
 */
public class ConcreteIterator implements Iterator {

    private List list = null;
    private int index = -1;

    public ConcreteIterator(List list) {
        this.list = list;
    }

    @Override
    public Object first() {
        this.index = 0;
        return list.get(index);
    }

    @Override
    public Object next() {
        Object o = null;
        if (this.hasnext()){
            o =  list.get(++index);
        }
        return o;
    }

    @Override
    public Object last() {
        index = list.size()-1;
        return list.get(index);
    }

    @Override
    public boolean hasnext() {
        if (index<list.size()-1){
            return true;
        }else {
            return false;
        }
    }
}

Iterator（抽象迭代器）

/**
 * 抽象迭代器
 * */
public interface Iterator {

    Object first();

    Object next();

    Object last();

    boolean hasnext();

}

Test

public class Test {

    public static void main(String[] args) {

        //创建一个对象聚合，并往聚合中添加数据
        String s1 = "1";
        String s2 = "2";
        String s3 = "3";
        Aggregate aggregate = new ConcreteAggregate();
        aggregate.add(s1);
        aggregate.add(s2);
        aggregate.add(s3);

        //获取聚合的迭代器，通过迭代器访问聚合内的数据
        Iterator iterator = aggregate.getIterator();

        System.out.println(iterator.first());
        System.out.println(iterator.next());
        System.out.println(iterator.last());
        System.out.println(iterator.hasnext());
    }

}

总结

其实有jdk自带的iterator()迭代器基本就够了，，无非就是封装一个操作容器的工具类，可以通过这个工具类来操作容器内的元素。