个人博客

http://www.milovetingting.cn

迭代器模式

模式介绍

迭代器模式又称为游标(Cursor)模式，是行为型设计模式之一。

模式定义

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

使用场景

遍历一个容器对象时。

简单使用

定义迭代器接口

/**
 * 迭代器接口
 * 
 * @author 160317250
 *
 * @param <T>
 */
public interface Iterator<T> {
    /**
     * 是否还有下一个元素
     * 
     * @return
     */
    boolean hasNext();

    /**
     * 返回当前位置的元素并将位置移至下一位
     * 
     * @return
     */
    T next();
}

定义迭代器实现类

/**
 * 具体迭代器类
 * @author 160317250
 *
 * @param <T>
 */
public class IteratorImpl<T> implements Iterator<T> {

    private List<T> list = new ArrayList<T>();
    private int cursor = 0;

    public IteratorImpl(List<T> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return cursor != list.size();
    }

    @Override
    public T next() {
        T obj = null;
        if (this.hasNext()) {
            obj = this.list.get(cursor++);
        }
        return obj;
    }

}

定义容器接口

/**
 * 容器接口
 * 
 * @author 160317250
 *
 */
public interface Container<T> {
    /**
     * 添加一个元素
     * 
     * @param obj
     */
    void add(T obj);

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

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

定义容器实现类

public class ContainerImpl<T> implements Container<T> {

    private List<T> list = new ArrayList<T>();

    @Override
    public void add(T obj) {
        list.add(obj);
    }

    @Override
    public void remove(T obj) {
        list.remove(obj);
    }

    @Override
    public Iterator<T> iterator() {
        return new IteratorImpl<>(list);
    }

}

调用

public class Main {

    public static void main(String[] args) {
        Container<String> container = new ContainerImpl<>();
        container.add("a");
        container.add("b");
        container.add("c");
        Iterator<String> iterator = container.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

输出结果:

a
b
c

小结

对于迭代器模式来说，其自身优点很明显也很单一，支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系，而缺点就是对类文件的增加。

迭代器模式发展至今，几乎每一种高级语言都有相应的内置实现，对于开发者而言，已经极少自己实现迭代器，因此对于迭代器模式更多的是在于了解。