设计模型系列—迭代器模式

开发 前端
本篇和大家一起来学习迭代器模式相关内容。

在现实生活以及程序设计中,经常要访问一个聚合对象中的各个元素,如“数据结构”中的链表遍历,通常的做法是将链表的创建和遍历都放在同一个类中,但这种方式不利于程序的扩展,如果要更换遍历方法就必须修改程序源代码,这违背了 “开闭原则”。

既然将遍历方法封装在聚合类中不可取,那么聚合类中不提供遍历方法,将遍历方法由用户自己实现是否可行呢?答案是同样不可取,因为这种方式会存在两个缺点:

  1. 暴露了聚合类的内部表示,使其数据不安全;
  2. 增加了客户的负担。

“迭代器模式”能较好地克服以上缺点,它在客户访问类与聚合类之间插入一个迭代器,这分离了聚合对象与其遍历行为,对客户也隐藏了其内部细节,且满足“单一职责原则”和“开闭原则”,如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

模式定义

提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式。

迭代器模式是通过将聚合对象的遍历行为分离出来,抽象成迭代器类来实现的,其目的是在不暴露聚合对象的内部结构的情况下,让外部代码透明地访问聚合的内部数据。

解决的问题

不同的方式来遍历整个整合对象。

模式组成

使用步骤 

步骤1:定义抽象迭代器角色。迭代器角色负责定义访问和遍历元素的接口,一般包括3个方法,即访问下一个元素next(),元素是否已经访问到底部hasNext(),以及删除当前指向的元素remove()。

  1. interface Iterator { 
  2.     Object first(); 
  3.  
  4.     Object next(); 
  5.  
  6.     boolean hasNext(); 

步骤2:定义具体迭代器角色。

  1. class ConcreteIterator implements Iterator { 
  2.     private List<Object> list = null
  3.     private int index = -1; 
  4.  
  5.     public ConcreteIterator(List<Object> list) { 
  6.         this.list = list; 
  7.     } 
  8.  
  9.     public boolean hasNext() { 
  10.         if (index < list.size() - 1) { 
  11.             return true
  12.         } else { 
  13.             return false
  14.         } 
  15.     } 
  16.  
  17.     public Object first() { 
  18.         index = 0; 
  19.         Object obj = list.get(index); 
  20.         ; 
  21.         return obj; 
  22.     } 
  23.  
  24.     public Object next() { 
  25.         Object obj = null
  26.         if (this.hasNext()) { 
  27.             obj = list.get(++index); 
  28.         } 
  29.         return obj; 
  30.     } 

步骤3:定义抽象聚合角色。

  1. interface Aggregate { 
  2.     public void add(Object obj); 
  3.  
  4.     public void remove(Object obj); 
  5.  
  6.     public Iterator getIterator(); 

步骤4:定义具体聚合角色。

  1. class ConcreteAggregate implements Aggregate { 
  2.     private List<Object> list = new ArrayList<Object>(); 
  3.  
  4.     public void add(Object obj) { 
  5.         list.add(obj); 
  6.     } 
  7.  
  8.     public void remove(Object obj) { 
  9.         list.remove(obj); 
  10.     } 
  11.  
  12.     public Iterator getIterator() { 
  13.         return (new ConcreteIterator(list)); 
  14.     } 

步骤5:测试

  1. 聚合的内容有:北京 上海 深圳  
  2. First:北京 

优点

  1. 访问一个聚合对象的内容而无须暴露它的内部表示。
  2. 遍历任务交由迭代器完成,这简化了聚合类。
  3. 它支持以不同方式遍历一个聚合,甚至可以自定义迭代器的子类以支持新的遍历。
  4. 增加新的聚合类和迭代器类都很方便,无须修改原有代码。
  5. 封装性良好,为遍历不同的聚合结构提供一个统一的接口。

缺点

增加了类的个数,这在一定程度上增加了系统的复杂性。

应用场景

  1. 当需要为聚合对象提供多种遍历方式时。
  2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
  3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。
  • 由于聚合与迭代器的关系非常密切,所以大多数语言在实现聚合类时都提供了迭代器类,因此大数情况下使用语言中已有的聚合类的迭代器就已经够了。

模式的扩展

迭代器模式常常与组合模式结合起来使用,在对组合模式中的容器构件进行访问时,经常将迭代器潜藏在组合模式的容器构成类中。当然,也可以构造一个外部迭代器来对容器构件进行访问,其结构如下:

源码中的应用

Java 中的容器对象有很多,基本都涉及到迭代器,我们以 ArrayList 作为例子,剖析它是如何应用迭代器模式的。

  • Java集合框架:List, Set, Map 都支持迭代

ArrayList 源码可以发现:

  • ArrayList 实现了 List 接口,使用 Object 数组存储元素;
  • 在 List 接口中定义了 iterator() 以及很多对操作集合的方法;
  • 在 ArrayList 中对 iterator() 进行了重写,并返回一个 Itr 对象;
  • Itr 是 ArrayList 的内部类,并且实现了 Iterator 接口。

部分源码展示

List接口

  1. public interface List<E> extends Collection<E> { 
  2.  Iterator<E> iterator(); 

Iterator接口

  1. public interface Iterator<E> { 
  2.   
  3.  boolean hasNext(); 
  4.  E next(); 
  5.  default void remove() { 
  6.         throw new UnsupportedOperationException("remove"); 
  7.     } 

ArrayList类和Itr类

  1. public class ArrayList<E> extends AbstractList<E> 
  2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  3.  public Iterator<E> iterator() { 
  4.         return new Itr(); 
  5.     } 
  6.  //Itr内部类 
  7.  private class Itr implements Iterator<E> { 
  8.         int cursor;       // index of next element to return 
  9.         int lastRet = -1; // index of last element returned; -1 if no such 
  10.         int expectedModCount = modCount; 
  11.         public boolean hasNext() { 
  12.             return cursor != size
  13.         } 
  14.         @SuppressWarnings("unchecked"
  15.         public E next() { 
  16.             checkForComodification(); 
  17.             int i = cursor
  18.             if (i >= size
  19.                 throw new NoSuchElementException(); 
  20.             Object[] elementData = ArrayList.this.elementData; 
  21.             if (i >= elementData.length) 
  22.                 throw new ConcurrentModificationException(); 
  23.             cursor = i + 1; 
  24.             return (E) elementData[lastRet = i]; 
  25.         } 
  26.         public void remove() { 
  27.             if (lastRet < 0) 
  28.                 throw new IllegalStateException(); 
  29.             checkForComodification(); 
  30.             try { 
  31.                 ArrayList.this.remove(lastRet); 
  32.                 cursor = lastRet; 
  33.                 lastRet = -1; 
  34.                 expectedModCount = modCount; 
  35.             } catch (IndexOutOfBoundsException ex) { 
  36.                 throw new ConcurrentModificationException(); 
  37.             } 
  38.         } 
  39.         @Override 
  40.         @SuppressWarnings("unchecked"
  41.         public void forEachRemaining(Consumer<? super E> consumer) { 
  42.             Objects.requireNonNull(consumer); 
  43.             final int size = ArrayList.this.size
  44.             int i = cursor
  45.             if (i >= size) { 
  46.                 return
  47.             } 
  48.             final Object[] elementData = ArrayList.this.elementData; 
  49.             if (i >= elementData.length) { 
  50.                 throw new ConcurrentModificationException(); 
  51.             } 
  52.             while (i != size && modCount == expectedModCount) { 
  53.                 consumer.accept((E) elementData[i++]); 
  54.             } 
  55.             // update once at end of iteration to reduce heap write traffic 
  56.             cursor = i; 
  57.             lastRet = i - 1; 
  58.             checkForComodification(); 
  59.         } 
  60.         final void checkForComodification() { 
  61.             if (modCount != expectedModCount) 
  62.                 throw new ConcurrentModificationException(); 
  63.         } 
  64.     } 

PS:以上代码提交在 Github :

https://github.com/Niuh-Study/niuh-designpatterns.git

 

责任编辑:姜华 来源: 今日头条
相关推荐

2021-06-22 15:27:13

设计模式迭代器模式Java

2010-04-29 08:53:11

PHP迭代器模式

2020-11-09 08:20:33

解释器模式

2022-01-19 08:21:12

设计装饰器模式

2021-01-04 09:43:24

Python 开发编程语言

2020-10-23 09:40:26

设计模式

2020-11-03 13:05:18

命令模式

2020-11-04 08:54:54

状态模式

2022-01-12 13:33:25

工厂模式设计

2011-07-07 16:14:37

Cocoa MVC 模型

2009-08-26 16:26:37

C#迭代器模式

2009-08-11 13:59:41

迭代器模式C# Iterator

2021-10-28 19:09:09

模式原型Java

2021-10-26 00:21:19

设计模式建造者

2012-01-13 15:59:07

2020-10-20 13:33:00

建造者模式

2020-10-28 11:56:47

桥接模式

2020-11-05 09:38:07

中介者模式

2021-03-02 08:50:31

设计单例模式

2021-09-29 13:53:17

抽象工厂模式
点赞
收藏

51CTO技术栈公众号