设计模式—迭代器模式

简介

作为开发者，势必会涉及到容器的操作，比如Java中的List、Map等，对容器的访问必然会涉及到遍历算法，如果将对容器的遍历封装在容器内部，对容器而言就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外提供遍历的接口方法，因为遍历状态的存储问题不能对同一个容器同时进行多个遍历操作，如果开发者不提供遍历算法让使用者自己去实现，又会对容器的内部细节暴露，正因如此，迭代器模式应运而生。

定义

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

使用场景

遍历一个容器对象时

关键点

一个迭代器接口，负责定义、访问和遍历元素的接口

一个或多个具体迭代器类，实现迭代器接口，并记录遍历的当前位置

一个容器接口，负责提供创建具体迭代器角色

具体容器类，具体迭代器相关联

实现

/**
 * 迭代器接口
 */
public interface Iterator<T> {

    /**
     * 是否还有下一个元素
     */
    boolean hasNext();

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

/**
 * List迭代器
 */
public class ListIterator<T> implements Iterator<T> {

    private List<T> list;
    private int cursor;

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

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

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

/**
 * 数组迭代器
 */
public class ArrayIterator<T> implements Iterator<T> {

    private T[] arrays;
    private int cursor;

    public ArrayIterator(T[] arrays) {
        this.arrays = arrays;
    }

    @Override
    public boolean hasNext() {
        return arrays != null && cursor != arrays.length;
    }

    @Override
    public T next() {
        T t = null;
        if (this.hasNext()) {
            t = arrays[cursor];
            cursor++;
        }
        return t;
    }
}

/**
 * 容器接口
 */
public interface ICollection<T> {

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

}

/**
 * List容器
 */
public class ListCollection<T> implements ICollection<T> {

    private List<T> list;

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

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

/***
 * 数组容器
 */
public class ArrayCollection<T> implements ICollection<T> {

    private T[] t;

    public ArrayCollection(T[] t) {
        this.t = t;
    }

    @Override
    public Iterator<T> iterator() {
        return new ArrayIterator<>(t);
    }
}

使用

list.add("LBJFAN_1");
list.add("LBJFAN_2");
list.add("LBJFAN_3");
ListCollection listCollection = new ListCollection(list);
Iterator iterator = listCollection.iterator();
while (iterator.hasNext()) {
    Log.i("Collection", iterator.next().toString());
}

小结

优点

支持以不同的方式去遍历一个容器对象，也可以遍历多个，弱化了容器类与遍历算法之间的关系

确点

类文件增多