迭代器模式（Iterator Pattern）

迭代器模式（提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合的底层）

如果集合元素是用不同的方式实现的，有数组，还有java的集合类，或其他方式，当要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，这时就可以考虑迭代器模式解决。

• 优点
  1、遍历一个聚合对象的内容而无须暴露它的内部表示。
  2、将存储数据和遍历数据的职责分离，符合单一职责原则。
  3、增加新的聚合类和迭代器类都很方便，无须修改原有代码。
• 缺点
  1、由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
• 类图
  
• 迭代器模式主要包含以下角色
  抽象迭代器角色(Iterator)：系统提供的接口，包含 hasNext()、next()、remove() 等方法。
  具体迭代器角色(concreteIterator)：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置
  抽象聚合角色(Aggregation)：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
  具体聚合角色(ConcreteAggregation )：实现抽象聚合类，返回一个具体迭代器的实例。
• 例子：ArrayList集合和数组运用迭代器模式

抽象迭代器角色（系统提供）

public interface Iterator<E> {
    boolean hasNext();
    E next();
	
	// jdk1.8之后，接口里面可以有默认方法和静态方法
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

具体迭代器角色

/**
 * 集合的迭代器实现
 */
public class ListIterator implements Iterator {
    private ArrayList<Object> list;
    private int index = 0;

    public ListIterator(ArrayList<Object> list) {
        this.list = list;
    }

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

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = list.get(index);
            index = index + 1;
        }
        return obj;
    }
}
/**
 * 数组的迭代器实现
 */
public class ArrayIterator implements Iterator {
    private Object[] array;
    private int index = 0;

    public ArrayIterator(Object[] array) {
        this.array = array;
    }

    @Override
    public boolean hasNext() {
        if (index < array.length) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public Object next() {
        Object obj = null;
        if (this.hasNext()) {
            obj = array[index];
            index = index + 1;
        }
        return obj;
    }
}

具体聚合角色

/**
 * 抽象聚合接口类
 */
public interface Aggregation {
    // 添加元素
    void add(Object obj);

    // 删除元素
    void remove(Object obj);

    // 生成迭代器
    Iterator createIterator();
}

抽象聚合角色

/**
 * 集合类型的聚合类
 */
public class ListAggregation implements Aggregation {
    private ArrayList<Object> list = new ArrayList<>();

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

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

    @Override
    public Iterator createIterator() {
        return new ListIterator(list);
    }
}
/**
 * 数组类型的聚合类
 */
public class ArrayAggregation implements Aggregation {
    private Object[] array = new Object[10];
    private int index = 0;
    private int size = 10;

    @Override
    public void add(Object obj) {
        if (index == size) {
            return;
        }
        this.array[index] = obj;
        this.index++;
    }

    @Override
    public void remove(Object obj) {
        List<Object> list = new ArrayList<>();
        list.addAll(Arrays.asList(array));
        list.remove(obj);
        this.array = list.toArray();
    }

    @Override
    public Iterator createIterator() {
        return new ArrayIterator(array);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        // 数组聚合测试
        System.out.println("数组聚合测试结果：");
        Aggregation array = new ArrayAggregation();
        array.add("水浒传");
        array.add("西游记");
        array.add("三国演义");
        array.add("红楼梦");
        array.remove("西游记");
        Iterator arrayIterator = array.createIterator();
        arrayIterator.forEachRemaining(arrayValue-> System.out.println(arrayValue));

        // 集合聚合测试
        System.out.println("集合聚合测试结果：");
        Aggregation list = new ListAggregation();
        list.add("我");
        list.add("最");
        list.add("不");
        list.add("好");
        list.add("看");
        list.remove("不");
        Iterator listIterator = list.createIterator();
        listIterator.forEachRemaining(arrayValue-> System.out.println(arrayValue));
    }
}
// 运行结果
数组聚合测试结果：
水浒传
三国演义
红楼梦
null
null
null
null
null
null
集合聚合测试结果：
我
最
好
看

• 在日常开发中，我们几乎不会自己写迭代器。除非需要定制一个自己实现的数据结构对应的迭代器，否则，开源框架提供的 API 完全够用，比如Java 中的 Collection、List、Set、Map 等都包含了迭代器。