二十、设计模式之迭代器模式

二十、设计模式之迭代器模式

---

能帮我们干什么？

主要解决什么问题？

主要解决的是 不同的方式来遍历整个整合对象
何时使用：遍历一个聚合对象。

优缺点

优点

• 单一职责原则。通过将体积庞大的遍历算法代码抽取为独立的类，可对客户端代码和集合进行整理。
• 开闭原则。可实现新型的集合和迭代器并将其传递给现有代码，无需修改现有代码。
• 可以并行遍历同一集合，因为每个迭代器对象都包含其自身的遍历状态。
  相似的，可以暂停遍历并在需要时继续。

缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

---

使用的场景

1、访问一个聚合对象的内容而无须暴露它的内部表示。
2、需要为聚合对象提供多种遍历方式。
3、为遍历不同的聚合结构提供一个统一的接口。

角色

二、角色组成

• 抽象迭代器（Iterator）：定义了遍历聚合对象所需的方法，包括hashNext()和next()方法等，用于遍历聚合对象中的元素。
• 具体迭代器（Concrete Iterator）：它是实现迭代器接口的具体实现类，负责具体的遍历逻辑。它保存了当前遍历的位置信息，并可以根据需要向前或向后遍历集合元素。
• 抽象聚合器（Aggregate）： 一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。
• 具体聚合器（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。

实现

如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。
关键代码：定义接口：hasNext, next。

代码案例
https://gitcode.net/k316378085/Java/-/tree/master/java/com/kongxiang/raindrop/dp/type/behavior/iterator

迭代器模式

容器返回迭代器实例
迭代器由每个容器自己单独实现

实现难度： ⭐️ ⭐️ ⭐️

定义迭代器

/**
 * 可迭代的。提供一个迭代器实例
 * @param 
 */
public interface Iterable<T>{

    public Iterator<T> iterator();
}

/**
 * 定义迭代器的两个方法
 * @param 
 */
public interface Iterator<T> {

    public boolean hasNext();

    public T next();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

容器实现可迭代接口

public class ListContainer<T> implements Iterable<T> {
    private List<T> list = new ArrayList<>();

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

    public void add(T t ){
        this.list.add(t);
    }

    public T get(int index){
        return  this.list.get(index);
    }

    public int size(){
      return   this.list.size();
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

迭代器实现

public class ListIterator<T> implements Iterator<T> {

    private ListContainer<T> list   ;

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

    private int pointer;

    @Override
    public boolean hasNext() {
        return pointer < list.size();
    }

    @Override
    public T next() {
        return list.get(pointer++);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用

public static void main(String[] args) {
        ListContainer<Integer> listContainer = new ListContainer<>();
        listContainer.add(1);
        listContainer.add(2);
        listContainer.add(3);
        listContainer.add(6);

        Iterator<Integer> iterator = listContainer.iterator();
        while (iterator.hasNext()){
            Integer next = iterator.next();
            System.out.println("--- : "+ next);
        }
    }
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

总结

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。
迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。