（22）Java设计模式 - 迭代器模式（Iterator Pattern）

小鱼儿 2022-05-19 11:20 254阅读 0赞

# 迭代器模式 #

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

迭代器模式属于行为型模式。

## 介绍 ##

**意图：**提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。  
**主要解决：**不同的方式来遍历整个整合对象。  
**何时使用：**遍历一个聚合对象。  
**如何解决：**把在元素之间游走的责任交给迭代器，而不是聚合对象。  
**关键代码：**定义接口：hasNext, next。  
**应用实例：**Java 中的 iterator。  
**优点：** 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。  
**缺点：**由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。  
**使用场景：** 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。  
**注意事项：**迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

UML类图

![70][]  
主要角色：

*  **Iterator（迭代器接口）**：该接口必须定义实现迭代功能的最小定义方法集，比如提供hasNext()和next()方法。
 *  **ConcreteIterator（迭代器实现类）**：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
 *  **Aggregate（容器接口）**：定义基本功能以及提供类似Iteratoriterator()的方法。
 *  **ConcreteAggregate（容器实现类）**：容器接口的实现类。必须实现Iteratoriterator()方法。

## 通用代码实现 ##

/**
     * 迭代器接口
     */
    public interface Iterator<T> {
    	/**
    	 * 是否还有下一个元素
    	 * @return
    	 */
    	boolean hasNext();
    	/**
    	 * 返回当前位置的元素，并将位置移动到下一位
    	 * @return
    	 */
    	T next();
    }
     
    /**
     * 具体迭代器
     */
    public class ConcreteIterator<T> implements Iterator<T> {
     
    	private List<T> list = new ArrayList<>();
    	
    	private int cursor = 0;
    	
    	public boolean hasNext() {
    		return cursor != list.size();
    	}
     
    	public T next() {
    		T obj = null;
    		if (this.hasNext()) {
    			obj = this.list.get(cursor++);
    		}
    		return obj;
    	}
     
    }
     
    /**
     * 容器接口
     */
    public interface Aggregate<T> {
    	/**
    	 * 添加一个元素
    	 * @param obj 元素对象
    	 */
    	void add(T obj);
    	
    	/**
    	 * 移除一个元素
    	 * @param obj 元素对象
    	 */
    	void remove(T obj);
    	
    	/**
    	 * 获取容器的迭代器
    	 * @return 迭代器对象
    	 */
    	Iterator<T> iterator();
    }
     
    /**
     * 具体容器接口
     */
    public class ConcreteAggregate<T> implements Aggregate<T> {
     
    	private List<T> list = new ArrayList<>();
    	
    	@Override
    	public void add(T obj) {
    		list.add(obj);
    	}
     
    	@Override
    	public void remove(T obj) {
    		list.remove(obj);
    	}
     
    	@Override
    	public Iterator<T> iterator() {
    		return new ConcreteIterator<>();
    	}	
    }
     
    /**
     * Client类
     */
    public class MainClass {
     
    	public static void main(String[] args) {
    		
    		Aggregate<String> agt = new ConcreteAggregate<>();
    		agt.add("aLin");
    		agt.add("jack");
    		agt.add("yushao");
    		
    		Iterator<String> itr = agt.iterator();
    		while (itr.hasNext()) {
    			System.out.println(itr.next());
    		}
    	}
     
    }

## 例子 ##

我们将创建一个叙述导航方法的 *Iterator* 接口和一个返回迭代器的 *Container* 接口。实现了 *Container* 接口的实体类将负责实现 *Iterator* 接口。

*IteratorPatternDemo*，我们的演示类使用实体类 *NamesRepository* 来打印 *NamesRepository* 中存储为集合的 *Names*。

![迭代器模式的 UML 图][UML]

### 步骤 1 ###

创建接口:

public interface Iterator {
       public boolean hasNext();
       public Object next();
    }

public interface Container {
       public Iterator getIterator();
    }

## 步骤 2 ##

创建实现了 *Container* 接口的实体类。该类有实现了 *Iterator* 接口的内部类 *NameIterator*。

public class NameRepository implements Container {
       public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};
     
       @Override
       public Iterator getIterator() {
          return new NameIterator();
       }
     
       private class NameIterator implements Iterator {
     
          int index;
     
          @Override
          public boolean hasNext() {
             if(index < names.length){
                return true;
             }
             return false;
          }
     
          @Override
          public Object next() {
             if(this.hasNext()){
                return names[index++];
             }
             return null;
          }     
       }
    }

### 步骤 3 ###

使用 *NameRepository* 来获取迭代器，并打印名字。

public class IteratorPatternDemo {
       
       public static void main(String[] args) {
          NameRepository namesRepository = new NameRepository();
     
          for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
             String name = (String)iter.next();
             System.out.println("Name : " + name);
          }  
       }
    }

### 步骤 4 ###

执行程序，输出结果：

Name : Robert
    Name : John
    Name : Julie
    Name : Lora

[70]: /images/20220519/885a633278b745d88cf1561efaa6c434.png
[UML]: /images/20220519/92203bc0917348a28c264102d6e007f8.png