厚积薄发打卡Day46: [itcast] GoF23通俗易懂的设计模式之 ＜迭代器模式＞

前言：

视频教程：黑马程序员Java设计模式详解，全网最全23种Java设计模式

什么是设计模式？

• 设计模式(Design Pattern)是前辈们对代码开发经验的总结，是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。
• 1995年，GoF(Gang of Four,四人组)合作出版了《设计模式：可复用面向对象软件的基础》一书，共收录了23种设计模式，人称 【GoF设计模式】

设计模式分类	具体模式
创建型模式： 它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。	⌛单例模式、⌛工厂模式、⌛抽象工厂模式、⌛建造者模式、⌛原型模式
结构型模式: 结构型模式描述如何将类或对象按某种布局组成更大的结构。	⌛适配器模式、⌛桥接模式、⌛装饰模式、⌛代理模式、⌛外观模式、⌛组合模式、⌛享元模式、
行为型模式: 这些设计模式特别关注对象之间的通信。	⌛模板方法模、⌛策略模式、⌛命令模式、⌛职责链模式、⌛状态模式、⌛观察者模式、⌛中介者模式、⌛迭代器模式、备忘录模式、解释器模式、访问者模式

迭代器模式

概述：

定义：

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

结构：

迭代器模式主要包含以下角色：

• 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。

• 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。

• 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。

• 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

题外话：

在需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，此时就应该考虑用迭代器模式。另外，需要对聚集有多种方式遍历时，也应该可以考虑用迭代器模式。 不知内部具体储存的对象，也就是说，能为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

不过现今来看迭代器模式实用价值远不如学习价值大了，MartinFlower 甚至在自己的网站上提出撤销此模式，因为现在高级编程语言如C#、Java 等本身已经把这个模式做在语言中了：

• 如 Java中的Iterator接口，JavaScript中的foreach等。
• 另外还有像IEnumerable 接口也是为迭代器模式而准备的。

不管如何，知其然也要知其所以然，学习一下GoF 的迭代器模式的基本结构，还是很有学习价值的。

温故而知新，研究历史是为了更好地迎接未来。

实例：

【例】定义一个可以存储学生对象的容器对象，将遍历该容器的功能交由迭代器实现，涉及到的类如下：

• Student对象：

  public class Student {
      //学生姓名
      private String name;
      //学号
      private String number;
      
  	//...省略其有参/无参/以及getter和setter方法
  }
  

• 聚合类：

  • 定义抽象容器类，包含添加元素，删除元素，获取迭代器对象的方法

  public interface StudentAggregate {
  
       void addStudent(Student student);
  
       void removeStudent(Student student);
  
       StudentIterator getStudentIterator();
  }
  

  • 定义具体的容器类，重写所有的方法

  public class StudentAggregateImpl implements StudentAggregate {
  
      private List<Student> list = new ArrayList<>();
  
      @Override
      public void addStudent(Student student) {
          this.list.add(student);
      }
  
      @Override
      public void removeStudent(Student student) {
          this.list.remove(student);
      }
  
      @Override
      public StudentIterator getStudentIterator() {
          return new StudentIteratorImpl(list);
      }
  }
  

• 迭代器：

  • 定义迭代器接口，声明hasNext、next方法

  public interface StudentIterator {
      boolean hashNext();
      Student next();
  }
  

  • 定义具体的迭代器类，重写所有的抽象方法

  public class StudentIteratorImpl implements StudentIterator {
      //定义对象容器
      private List<Student> list;
      //定义下标：
      private int position = 0;
  
      public StudentIteratorImpl(List<Student> list) {
          this.list = list;
      }
  
      @Override
      public boolean hashNext() {
          return position < list.size();
      }
  
      @Override
      public Student next() {
          Student student = list.get(position);
          position++;
          return student;
  //        return list.get(position++);
      }
  }
  

• 运行效果：

  

小结：

• 优缺点：

  • 优点：
    • 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。
    • 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。
    • 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足 “开闭原则” 的要求。
  • 缺点：
    • 增加了类的个数，这在一定程度上增加了系统的复杂性，（可以忽略不计）

• 使用场景：

  • 当需要为聚合对象提供多种遍历方式时。
  • 当需要为遍历不同的聚合结构提供一个统一的接口时。
  • 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

应用案例：

正如开篇的题外话：许多变成语言已经在内部实现了 迭代器模式了，以Java举例：

List<String> list = new ArrayList<>();
//list.iterator()方法返回的肯定是Iterator接口的子实现类对象
Iterator<String> iterator = list.iterator(); 
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

单列集合List 都使用到了迭代器，我们以ArrayList举例来说明

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

学习ArrayList源码：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    public Iterator<E> iterator() {
        return new Itr();
    }
    
    private class Itr implements Iterator<E> {
        int cursor;       // 下一个要返回元素的索引
        int lastRet = -1; // 上一个返回元素的索引
        int expectedModCount = modCount;

        Itr() {}
		
        //判断是否还有元素
        public boolean hasNext() {
            return cursor != size;
        }

        //获取下一个元素
        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];
        }
        ...
}

这部分代码还是比较简单，大致就是在 iterator 方法中返回了一个实例化的 Iterator 对象：

• Itr是一个内部类，它实现了 Iterator 接口并重写了其中的抽象方法。

因此，当我们想在Java中使用迭代器模式，只需要实现：java.util.Iterable并实现其中的iterator()方法使其返回一个 java.util.Iterator 的实现类即可。