一起学设计模式 - 迭代器模式

2019年3月3日 294次阅读 来源: 设计模式

迭代器模式（Iterator Pattern）属于行为型模式的一种，提供一种方法访问一个容器中各个元素，而又不需要暴露该对象的内部细节。

<!– more –>

概述

迭代器模式听起来可能感觉很陌生，但是实际上，迭代器模式是所有设计模式中最简单也是最常用的设计模式，正是因为太常用了，所以导致很多人忽略了它的存在。

在实际的开发过程中，我们可能需要针对不同的需求，可能需要以不同的方式来遍历整个整合对象，但又不希望在聚合对象的抽象接口层中充斥着各种不同的便利操作。这个时候我们就需要这样一种东西，它应该具备如下三个功能：

  • 能够便利一个聚合对象。
  • 我们不需要了解聚合对象的内部结构。
  • 能够提供多种不同的遍历方式。

迭代器模式： 把在元素之间游走的责任交给迭代器，而不是聚合对象。简化了聚合的接口和实现，让聚合更专注在它所应该专注的事情上，这样做更加符合单一责任原则。

UML结构图

《一起学设计模式 - 迭代器模式》

模式结构

  • Iterator（抽象迭代器）： 具体迭代器需要实现的接口，提供了游走聚合对象元素之间的方法
  • ConcreteIterator（具体迭代器）： 对具体的聚合对象进行遍历，每一个聚合对象都应该对应一个具体的迭代器。
  • Aggregate（抽象聚合类）： 存储和管理元素对象，声明了createIterator()用于创建一个迭代器对象，充当抽象迭代器工厂角色
  • ConcreteAggregate（具体聚合类）： 实现了在抽象聚合类中声明的createIterator()，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

案例

UML图如下：

《一起学设计模式 - 迭代器模式》

1.先定义抽象迭代器“

interface Iterator<E> {

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

    //取出下一个对象
    E next();
}

2.在定义一个具体迭代器对象，实现了Iterator中的方法

class MusicIterator<E> implements Iterator<E> {

    private E[] es;
    private int position = 0;

    public MusicIterator(E[] es) {
        this.es = es;
    }

    @Override
    public boolean hasNext() {
        return position != es.length;
    }

    @Override
    public E next() {
        E e = es[position];
        position += 1;
        return e;
    }
}

3.接下来定义抽象聚合类（常为 Collection ， List ， Set 等）

interface AbstractList<E> {

    void add(E e);

    Iterator<E> createIterator();
}

4.最后创建具体聚合类 （常为 ArrayList , HashSet 等，是抽象聚合类的实现类）

class MusicList implements AbstractList<String> {

    private String[] books = new String[5];
    private int position = 0;


    @Override
    public void add(String name) {
        books[position] = name;
        position += 1;
    }

    @Override
    public Iterator<String> createIterator() {
        return new MusicIterator<>(books);
    }
}

5.创建测试工程

public class Client {

    public static void main(String[] args) {
        AbstractList<String> list = new MusicList();
        list.add("凉凉");
        list.add("奇谈");
        list.add("红颜");
        list.add("伴虎");
        list.add("在人间");
        Iterator<String> iterator = list.createIterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

6.运行效果

凉凉
奇谈
红颜
伴虎
在人间

至此一个简单的迭代器就完成了，实现了对容器的遍历。可以看到迭代器在Client中遍历时根本不需要知道他底层的实现，只需要通过迭代器来遍历就可以了。

JDK中应用

上文介绍了自己实现一个简单的迭代器，看完的应该就不陌生了，它其实在JAVA的很多集合类中被广泛应用，接下来看看JAVA源码中是如何使用迭代器模式的。

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

看完这段代码是不是很熟悉，与我们上文代码基本类似

  • List：抽象聚合器
  • ArrayList：具体的聚合类
  • Iterator：抽象迭代器
  • list.iterator()：返回的是实现了Iterator接口的具体迭代器对象

接下来看下ArrayList中的iterator是如何实现的

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

这部分代码还是比较简单，大致就是在iterator方法中返回了一个实例化的Iterator对象。Itr是一个内部类，它实现了Iterator接口并实现了其中的方法。

当我们在使用JAVA开发的时候，想使用迭代器模式的话，只要让我们自己定义的容器类实现java.util.Iterable并实现其中的iterator方法使其返回一个java.util.Iterator的实现类就可以了。

总结

迭代器模式与集合共生共死的，一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，当然也需要引入迭代器模式，给我们的容器实现一个迭代器。但在绝大多数情况，我们是不需要自己实现的，基本都内置了

优点

  • 支持不同方式遍历一个聚合对象，在同一个聚合上可以有多个遍历。
  • 简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法。
  • 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码

缺点

  • 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
  • 抽象迭代器的设计难度较大，需要充分考虑到系统将来的扩展，例如JDK内置迭代器Iterator就无法实现逆向遍历，如果需要实现逆向遍历，只能通过其子类ListIterator等来实现，而ListIterator迭代器无法用于操作Set类型的聚合对象。在自定义迭代器时，创建一个考虑全面的抽象迭代器并不是件很容易的事情。

说点什么

全文代码：https://gitee.com/battcn/design-pattern/tree/master/Chapter14/battcn-iterator

  • 个人QQ：1837307557
  • battcn开源群（适合新手）：391619659

微信公众号：battcn（欢迎调戏）

福利

关注公众号：battcn，回复springboot即可获得 <Spring Boot从入门到实战 基础实战系列教程全集> 与 <2017最新spring boot 外卖实战微信公众平台视频教程>

    原文作者：设计模式
    原文地址: https://segmentfault.com/a/1190000012232509
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞