迭代器模式——Iterator

关于迭代器(Iterator)

 迭代器这个名词想来我们已经不陌生了，在集合中我们就学习过迭代器，并掌握了如何使用迭代器来遍历集合中的元素。

例如：
List<String> list = new ArrayList<>();
list.add("anc");
list.add("cvl");
list.add("uio");
list.add("ope");

Iterator iterator = list.iterator();
while(iterator.hasNext()){
      System.out.print(list.next());
}
输出：anc cvl uio ope

 实际上，迭代器就是反复同一件事的一个循环，就如同for(int i = 0; i < 100; i++)中的i++，只要符合条件就加1，直到遍历完每一个元素后就退出，而迭代器模式(Iterator模式)的思想也就是来自于此。迭代器模式是一种没落的模式，除非产品性质的需要，否则不会单独去写一个迭代器模式(Java中的集合就对迭代器模式进行优秀的封装，基本上不用认为扩展，都能满足我们的需求)。我们可以看看迭代器的定义：迭代器提供一种方法访问一个容器对象中各个元素，而又不暴露该对象的细节。通俗点说，迭代器的诞生就是为遍历容器(容器就是能持有对象的集合，如Collection，Set)中的元素服务的。

迭代器模式——你在不在？我要揍你一顿

 举一个例子，详细讲讲什么是迭代器模式

 在一个风和日丽的早晨，阳光明媚，春暖花开，打开古老的藏书阁，我要找一本心仪的古书陶冶一下情操，可是让我很郁闷的是，由于时间太久没人整理，很多书都凌乱的放在书架上，所以我费了老大的劲儿才把书籍找到。我就在想，要是有一个这样的物件就好了，它能在我想要从一堆杂乱无章的事物中寻找某一件东西时，它能按整齐的把它排列(排列顺序自己选择)好，这样我找的时候不就容易多了，我冥思苦想很久，找了很多上古典籍查阅(《设计模式之禅》，《图解设计模式》)中找到了答案，那就是上古秘书——迭代器模式。

 现有一个书架BookShelf，有一堆书Book，我想把书放到书架上，并按照书的名字按顺序显示出来。看一下示例图

程序的类图如下

类和接口

逐步剖析(请直接看代码)

Aggregate接口：表示集合的接口，相当于Java集合中Collection，List等集合接口

/**
 * 表示集合的接口
 */
public interface Aggregate {

    /**
	   * 该方法用于生成一个遍历结合的迭代器
	   *
	   * 在遍历集合中的元素时吗，调用iterator方法生成一个实现了Iterator接口的类的实例
	   * @return
	  */
    public abstract Iterator iterator();

}

Iterator接口：表示用于遍历集合的接口

/**
 * 用于遍历集合的接口：遍历集合中的元素，其作用相当于循环语句中的循环变量
 */
public interface Iterator {

    	/**
	     * 判断是否存在下一个元素
	     * @return
	   */
     public abstract boolean hasNext();

     /**
	   * 返回集合中的一个元素
	   * @return
	  */
    public abstract Object next();

}

BookShelf类：实现了Aggregate接口，表示一个书籍的集合，可以看成Java集合框架中的实现类

/**
 * 表示书架类，可以看成是一个书的集合，所以需要实现Aggregate接口
 */
public class BookShelf<T> implements Aggregate {

private Book[] books;// 可见性设置为private，避免不小心篡改
private int last;//标识最后一本书的索引

public BookShelf(int maxsize) {
     this.books = new Book[maxsize];// 生成BookShelf实例的时候指定了books的大小
}

     //根据索引得到书籍
public Book getBookAt(int index) {
     return books[index];
}

    //向书架上添加书籍
public void appendBook(Book book) {
     this.books[last] = book;
     last++;
}

    //返回书籍的数量
public int getLength() {
    return last;
}

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

}

BookShelfIterator类：Iterator的实现类

/**
 * 遍历书籍的迭代器实现(Iterator)类
 * @param <T>
 */
public class BookShelfIterator<T> implements Iterator {
private BookShelf<T> bookShelf;//表示BookShelfIterator要遍历的书架
private int index;//表示迭代器当前指向的书的索引

 //初始化
public BookShelfIterator(BookShelf<T> bookShelf) {
      this.bookShelf = bookShelf;
      this.index = 0;
}

 @Override
public boolean hasNext() {
<!-- if (index < bookShelf.getLength()) {//如果当前索引小于书架书籍的数量，表名下一本书还存在，继续遍历
         return true;
} else {
         return false;
} -->

 return index != bookShelf.getLength;
}

/**
	 * next()方法有两个作用：
	 * 			>返回当前索引对应的书籍实例
	 *          >并将index指向下一个元素 >>>> 这和for循环中的i++很像
*/
@Override
public Object next() {
     Book book = bookShelf.getBookAt(index);//将对应索引的书一一返回
     index++;
     return book;
 }
}

Book类：书籍类(实体类)

public class Book {

private String name;

public Book(String name) {
     super();
     this.name = name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

@Override
public String toString() {
    return "Book [name=" + name + "]";
}

}

下面是Main方法

public class Main {

  public static void main(String[] args) {

    BookShelf<Book> bookShelf = new BookShelf<>(4);

    bookShelf.appendBook(new Book("雪国"));
    bookShelf.appendBook(new Book("山中古音"));
    bookShelf.appendBook(new Book("天堂"));
    bookShelf.appendBook(new Book("一个人的路"));

    Iterator iterator = bookShelf.iterator();

    while(iterator.hasNext()) {
      System.out.println(iterator.next());
    }
  }

}

运行结果：
Book [name=雪国]
Book [name=山中古音]
Book [name=天堂]
Book [name=一个人的路]

集合框架中的迭代器模式(源码解析)

 上面是我们自己写的迭代器模式，用我们自己的想法实现了一个简单的迭代器，怎么样，你对迭代器了解有多少了呢，如果你还是不清楚，那我们再来看看Java集合框架是如何运用迭代器的。我将主要以源码的方式解析，你会发现其实和我上面写的差不多。

我就使用List接口进行解析，List定义了如下方法
Iterator<E> iterator();

Iterator接口：
public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    //该方法与函数式接口有关(lambda表达式)
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

以List的一个实现类ArrayList来看看如何实现的

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

//Itr是AbstractList的一个成员内部类(其实ArrayList也有一个Itr的成员内部类
  只不过这是优化版本)
private class Itr implements Iterator<E> {
      int cursor;       //表示下一个要访问的元素的索引
      int lastRet = -1; //表示上一个元素的索引
      int expectedModCount = modCount;//表示对ArrayList修改次数的期望值，它的初始值为modCount(modCount是AbstractList类中的一个成员变量)

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

     public E next() {
         checkForComodification();
         try {
             int i = cursor;//下一个元素的索引
             E next = get(i);//通过该索引得到实例
             lastRet = i;//将该索引赋值给表示上一个元素索引的变量
             cursor = i + 1;//指向下一个元素
             return next;//返回当前实例
         } catch (IndexOutOfBoundsException e) {
             checkForComodification();
             throw new NoSuchElementException();
         }
     }

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

         try {
             AbstractList.this.remove(lastRet);
             if (lastRet < cursor)
                 cursor--;
             lastRet = -1;
             expectedModCount = modCount;
         } catch (IndexOutOfBoundsException e) {
             throw new ConcurrentModificationException();
         }
     }

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

深入研究一下

 OK，上面就是迭代器在集合框架中的使用，现在我们或许就理解了为什么在学习集合的迭代器器时说，我们是去获取一个迭代器，而并非是我们new一个迭代器对象，下面我们来看看迭代器模式的类图，并分析一下我们为什么要使用迭代器

• Iterator(迭代器)：该角色定义了顺序逐个遍历元素的接口
• ConcreteIterator(具体的迭代器)：实现Iterator接口
• Aggregate(集合)：定义创建Iterator角色的接口
• ConcreteAggregate(具体的集合)：该角色负责实现Aggregate所定义的接口

 看了上面介绍的迭代器模式，我们或许头有点晕，既然同是迭代，为什么我们不去使用更为普通的迭代方式，如for循环呢，非要用这种复杂的设计模式干什么，其实回到前面迭代器模式的定义：迭代器模式提供一种顺序访问一个聚合对象中各个元素的方法，而又不暴露该对象的内部实现。

举个例子：我是车站的售票员，对于我来说，我只是负责售票的，其他的事情我一概不管，对于我来说，只有一个原则，那就是只有买了票才能乘车，不管你是中国人外国人，不管你是小偷还是杀人犯，只要你没买票就不能乘车，我不用管乘车对象是什么，我只管你有没有买票。

 如同上面举的那个例子，这里只是用了Iterator的hasNext和next方法，并没有调用BookShelf的方法，也就是说，while循环并不依赖于BookShelf的实现。不管BookShelf如何变化，只要BookShelf的iterator方法能返回正确的Iterator实例，即使不对while循环做任何修改，都可以正常工作。设计模式的作用就是帮助我们编写可复用的类。而可复用的含义就是将类视为“组件”，当一个组件方法发生变化时，不需要对其他组件进行修改或者只需要进行很小的修改就可以了，大大提高了代码的重用率。

while(iterator.hasNext()){
  System.out.println(iterator.next());
}

结语

迭代器模式是一种古老的设计模式，也是一种非常常见的设计模式，它已经完美的镶嵌于聚合关系中，如Java的集合框架，几乎每一个集合类都对迭代器模式进行了封装。正是由于它的普遍性，所以很多大佬都提出将迭代器模式从23中设计模式中删除。不管迭代器模式在未来是否还能存在于设计模式家族中，我们只需要知道，应用之广泛则证明其价值，所以值得我们去学习研究它的思想精髓。

推荐书籍与网站：

• 《图解设计模式》 《大话设计模式》 《设计模式》 《Java设计模式》

• http://www.cnblogs.com/dolphin0520/p/3933551.html