设计模式之：Iterator迭代器

Iterator迭代器

提供一种方法访问一个容器中的各个元素对象而又不暴露该对象的内部细节

 

当需要访问一个容器中的对象，而不管这些对象内部是什么都需要遍历的时候就可以考虑使用Iterator迭代器模式，

为遍历不同的对象提供开始、下一个、是否结束、当前哪一项等统一的接口

对于容器的遍历方式提供抽象的遍历接口

迭代器是为容器服务的，凡是能容纳所有对象类型的储存都可以称之为容器，比如Collection集合类型,Set类型等

 

Iterator迭代器设计UML图

说明：

  Aggregate聚集容器类只管理容器元素的增减，聚集容器元素的遍历完全交由iterator迭代器负责

  Iterator:抽象迭代器类，定义访问和遍历元素的接口

  ConreteIterator:具体迭代器类，继承自Iterator抽象类，具体实现遍历方法

  Aggregate:抽象容器类，提供创建具体迭代器的接口

  ConreteAggregate:具体容器类，继承自Aggregate抽象类，具体实现创建迭代器的对象

  Client:测试Iterator迭代器模式的客户端

 

Java实现Iterator Pattern

demo:售票员遍历车箱内李刚、吴叫兽、冯天叫等乘客售票行为

Iterator抽象迭代器类：Iterator.java

package gof.iterator;
//iterator接口
public interface Iterator {
	//Iterator的方法
	public abstract boolean hasNext();
	public abstract Object next();
	public abstract Object getFirst();
	public abstract Object getLast();
    public abstract Object currentItem(int currentmIndex);
    public abstract void resetIndex();
}

ConreteIterator 具体迭代器类： ConreteIterator.java

package gof.iterator;
//iterator具体实现类
public class ConreteIterator implements Iterator {
	private ConreteAggregate carCastle;  //引用车箱
	private int index;
	
	public ConreteIterator(ConreteAggregate conreteAggregate){
		this.carCastle = conreteAggregate;
		this.index = 0;
	}
	public void resetIndex(){
		this.index = 0;
	}
	public boolean hasNext() {
		if(index < carCastle.getLength()){
			return true;
		}else{
			return false;
		}
	}
	public Object next() {
		return carCastle.getPassenger(index++);
	}
	public Object getFirst() {
       	return carCastle.getPassenger(0);
	}
	public Object getLast() {
		return carCastle.getPassenger(carCastle.getLength()-1);
	}
	public Object currentItem(int currentIndex) {
		return carCastle.getPassenger(currentIndex);
	}
}

Aggregate 抽象容器类： Aggregate.java

package gof.iterator;
//容器接口
public interface Aggregate {
	public abstract Iterator iterator();
}

ConreteAggregate 具体容器类： ConreteAggregate.java

package gof.iterator;

import java.util.ArrayList;

//容器具体实现类,只负责容器元素的添加删除和实例化具体的Iterator
public class ConreteAggregate implements Aggregate {
	private ArrayList<Passenger> passengerList = new ArrayList<Passenger>();
	//上车一位乘客
	public boolean addPassenger(Passenger passenger){
		return this.passengerList.add(passenger);
	}
	//下车一位乘客
	public boolean removePassenger(Passenger passenger){
		return this.passengerList.remove(passenger);
	}
	//目前车厢内多少乘客数
	public int getLength(){
		return this.passengerList.size();
	}
	//索引
	public Passenger getPassenger(int index){
		if(passengerList.size()==0){
			return null;
		}else{
			if(passengerList.size()<index){
				return null;
			}else{
				return passengerList.get(index);
			}
		}
	}
	//实例化具体的Iterator
	public Iterator iterator() {
		return new ConreteIterator(this);
	}
}

Passenger 乘客类： Passenger.java

package gof.iterator;
//乘客类
public class Passenger {
	private String name = "";
	public Passenger(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
}

Client 测试类： IteratorTest.java

package gof.iterator;
//测试Iterator
public class IteratorTest {
	public static void main(String[] args) {
		ConreteAggregate aggCarCastle = new ConreteAggregate();
		aggCarCastle.addPassenger(new Passenger("李刚"));
		aggCarCastle.addPassenger(new Passenger("吴叫兽"));
		aggCarCastle.addPassenger(new Passenger("冯天叫"));
		aggCarCastle.addPassenger(new Passenger("菲律病"));
		Iterator iterator = aggCarCastle.iterator();
		Passenger passenger; 
		//迭代遍历所有元素
		while(iterator.hasNext()){
			passenger = (Passenger)iterator.next();
			System.out.print(passenger.getName() + " ");
		}
		System.out.println();
		//遍历第一个
		passenger = (Passenger)iterator.getFirst();
		System.out.println("遍历第一个:" + passenger.getName());
		//遍历最后一个
		passenger = (Passenger)iterator.getLast();
		System.out.println("遍历最后一个:" + passenger.getName());
		//遍历当前某一个
		passenger = (Passenger)iterator.currentItem(1);
		System.out.println("遍历当前某一个:" + passenger.getName());
		
		aggCarCastle.removePassenger(passenger);
		//迭代遍历remove后的所有元素
		iterator.resetIndex();
		while(iterator.hasNext()){
			passenger = (Passenger)iterator.next();
			System.out.print(passenger.getName() + " ");
		}
	}
}
/*输出结果:
李刚 吴叫兽 冯天叫 菲律病 
遍历第一个:李刚
遍历最后一个:菲律病
遍历当前某一个:吴叫兽
李刚 冯天叫 菲律病 
*/

总结:

 迭代器(Iterator)模式就是分离了集合对象的遍历，抽象出一个迭代其类来负责集合对象的遍历

如此既不会暴露集合对象的内部又可以放便地遍历集合对象内部的数据。

 

如上，即使应用需求假设对ConreteAggregate类进行重构，但是客户端的遍历代码并不会受到任何影响，依然是hasNext()等

但是如果ConreteAggregate的实现完全改变，尤其是getPassenger方法，则必须修改ConreteIterator类了

因为ConreteAggregate和ConreteIterator还是有一定的耦合，希望朋友们有好的指正修正！

 

Iterator Pattern现已是一个没落的设计模式，一般的设计中不会单独写一个迭代其模式。

GOF设计大师之前就已经建议将Iterator模式从23种设计模式中去除

在java中本身的Iterator已经足够满足coder的一般要求，当然再coding也完全取决于你的意愿！