设计模式 - 迭代器模式

概述

        迭代器模式（Iterator Pattern）又称为游标(Cursor)模式是行为模式之一。

定义

        迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不需要暴露该对象的内部表示。
#使用场景#
        遍历一个容器对象时。

UML类图

示例代码

创建一个迭代器接口

        迭代器接口一般包括hasNext()和next两个方法，hasNext()用于判断是否还有下一个元素，而next()用于返回当前元素的的值。

public interface Iterator<T> {

    /**
     * 是否还有下一个元素
     * @return true表示有，false表示没有
     */
    boolean hasNext();

    /**
     * 返回当前元素的值
     * @return T
     */
    T next();
}

创建具体的迭代器

        具体的迭代器的迭代器中有数据缓存，并记录当前遍历的位置。其中缓存数据可以使用List、Map或者数组，用来缓存迭代的数据，在迭代时便于取出。

public class ConcreteIterate<T> implements Iterator<T> {
    private List<T> list = new ArrayList<>();
    private int cursor;

    public ConcreteIterate(List<T> list) {
        this.list = list;
        cursor = 0;
    }

    /**
     * 是否还有下一个元素
     * @return true表示有，false表示没有
     */
    public boolean hasNext() {
        return cursor < list.size();
    }

    /**
     * 返回当前元素的值
     * @return T
     */
    public T next() {
        T obj = null;
        if (this.hasNext()) {
            obj = list.get(cursor);
            cursor++;
        }
        return obj;
    }
}

创建具体的容器接口类

public interface Aggregate<T> {

    /**
     * 添加一个元素
     * @param obj 元素对象
     */
    void add(T obj);

    /**
     * 删除一个元素
     * @param obj 元素对象
     */
    void remove(T obj);

    /**
     * 获取容器的迭代器
     * @return
     */
    Iterator<T> iterateor();
}

创建具体的容器

public class ConcreteAggregate<T> implements Aggregate<T> {

    private List<T> list;

    public ConcreteAggregate() {
        this.list = new ArrayList<T>();
    }

    /**
     * 添加一个元素
     * @param obj 元素对象
     */
    public void add(T obj) {
        list.add(obj);
    }

    /**
     * 删除一个元素
     * @param obj 元素对象
     */
    public void remove(T obj) {
        list.remove(obj);
    }

    /**
     * 获取容器的迭代器
     * @return
     */
    public Iterator<T> iterateor() {
        return new ConcreteIterate<T>(list);
    }

    @Override
    public String toString() {
        return "ConcreteAggregate{" +
                "list=" + list +
                '}';
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Aggregate<Stu> aggregate = new ConcreteAggregate<>();
        aggregate.add(new Stu(1, "A"));
        aggregate.add(new Stu(2, "B"));
        aggregate.add(new Stu(3, "C"));
        aggregate.add(new Stu(4, "D"));

        System.out.println(aggregate.toString());

        // 移除一个元素
        aggregate.remove(new Stu(2, "B"));
        System.out.println(aggregate.toString());

        // 获取迭代器
        Iterator<Stu> iterator = aggregate.iterateor();
        // 迭代
        while (iterator.hasNext()) {
            System.out.println(iterator.next().toString());
        }
    }
}

        Log打印

ConcreteAggregate{list=[Stu{id=1, name='A'}, Stu{id=2, name='B'}, Stu{id=3, name='C'}, Stu{id=4, name='D'}]}
ConcreteAggregate{list=[Stu{id=1, name='A'}, Stu{id=3, name='C'}, Stu{id=4, name='D'}]}
Stu{id=1, name='A'}
Stu{id=3, name='C'}
Stu{id=4, name='D'}