1七、行为型-迭代器模式（Iterator）

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。

迭代器模式包含以下几个角色：

● Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。
● ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中经过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标一般是一个表示位置的非负整数。
● Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于建立一个迭代器对象，充当抽象迭代器工厂角色。
● ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例

一、主要优势

(1) 它支持以不一样的方式遍历一个聚合对象，在同一个聚合对象上能够定义多种遍历方式。在迭代器模式中只须要用一个不一样的迭代器来替换原有迭代器便可改变遍历算法，咱们也能够本身定义迭代器的子类以支持新的遍历方式。
(2) 迭代器简化了聚合类。因为引入了迭代器，在原有的聚合对象中不须要再自行提供数据遍历等方法，这样能够简化聚合类的设计。
(3) 在迭代器模式中，因为引入了抽象层，增长新的聚合类和迭代器类都很方便，无须修改原有代码，知足“开闭原则”的要求

二、主要缺点

(1) 因为迭代器模式将存储数据和遍历数据的职责分离，增长新的聚合类须要对应增长新的迭代器类，类的个数成对增长，这在必定程度上增长了系统的复杂性。
(2) 抽象迭代器的设计难度较大，须要充分考虑到系统未来的扩展，例如JDK内置迭代器Iterator就没法实现逆向遍历，若是须要实现逆向遍历，只能经过其子类ListIterator等来实现，而ListIterator迭代器没法用于操做Set类型的聚合对象。在自定义迭代器时，建立一个考虑全面的抽象迭代器并非件很容易的事情。

三、适用场景

(1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。
(2) 须要为一个聚合对象提供多种遍历方式。
(3) 为遍历不一样的聚合结构提供一个统一的接口，在该接口的实现类中为不一样的聚合结构提供不一样的遍历方式，而客户端能够一致性地操做该接口

王者荣耀中的迭代器模式（英雄浏览）：

/**
 * 2018/12/6
 * 抽象聚合类
 *
 * @author machuanpeng
 */
public abstract class AbstractObjectList {
    
	protected List<Object> objects = new ArrayList<Object>();
 
	public AbstractObjectList(List objects) {
		this.objects = objects;
	}
	
	public void addObject(Object obj) {
		this.objects.add(obj);
	}
	
	public void removeObject(Object obj) {
		this.objects.remove(obj);
	}
	
	public List getObjects() {
		return this.objects;
	}
	
    //声明建立迭代器对象的抽象工厂方法
	public abstract AbstractIterator createIterator();
}

/**
 * 2018/12/6
 * 英雄列表聚合类
 *
 * @author machuanpeng
 */
public class HeroList extends AbstractObjectList {
	public HeroList(List products) {
		super(products);
	}
	
    /**实现建立迭代器对象的具体工厂方法*/
	public AbstractIterator createIterator() {
		return new HeroIterator(this);
	}
}

/**
 * 2018/12/6
 * 抽象迭代器
 *
 * @author machuanpeng
 */
interface AbstractIterator {
	public void next(); //移至下一个元素
	public boolean isLast(); //判断是否为最后一个元素
	public void previous(); //移至上一个元素
	public boolean isFirst(); //判断是否为第一个元素
	public Object getNextItem(); //获取下一个元素
	public Object getPreviousItem(); //获取上一个元素
}

public class HeroIterator implements AbstractIterator {
	private HeroList heroList;
	private List heros;
	private int cursor1; //定义一个游标，用于记录正向遍历的位置
	private int cursor2; //定义一个游标，用于记录逆向遍历的位置
	
	public HeroIterator(HeroList list) {
		this.heroList = list;
		this.heros = list.getObjects(); //获取集合对象
		cursor1 = 0; //设置正向遍历游标的初始值
		cursor2 = heros.size() -1; //设置逆向遍历游标的初始值
	}
	
	public void next() {
		if(cursor1 < heros.size()) {
			cursor1++;
		}
	}
	
	public boolean isLast() {
		return (cursor1 == heros.size());
	}
	
	public void previous() {
		if (cursor2 > -1) {
			cursor2--;
		}
	}
	
	public boolean isFirst() {
		return (cursor2 == -1);
	}
	
	public Object getNextItem() {
		return heros.get(cursor1);
	} 
		
	public Object getPreviousItem() {
		return heros.get(cursor2);
	} 	
}

测试：

public class Client {
	public static void main(String args[]) {
		List heros = new ArrayList();
		heros.add("百里守约");
		heros.add("牛魔");
		heros.add("典韦");
		heros.add("甄姬");
		heros.add("达摩");
			
		AbstractObjectList list;
		AbstractIterator iterator;
		
		list = new HeroList(heros); //建立聚合对象
		iterator = list.createIterator();	//建立迭代器对象
		
		System.out.println("正向遍历：");	
		while(!iterator.isLast()) {
			System.out.print(iterator.getNextItem() + "，");
			iterator.next();
		}
		System.out.println("-----------------------------");
		System.out.println("逆向遍历：");
		while(!iterator.isFirst()) {
			System.out.print(iterator.getPreviousItem() + "，");
			iterator.previous();
		}
	}
}