- 迭代器模式：提供一个方法去顺序访问一个集合中的元素，而又不暴露这些元素的内部表示
在软件模式中的聚合对象一般有两个功能，一个就是进行基本的存储元素。另一个功能就是经行遍历的功能。但是其实第二个功能可以将其变化，或者说将其抽离出来作为一个专门的方法进行使用。
- 角色
1、Iterator 抽象迭代类，一般为接口或者抽象类，在此类中一般有FIRST（）方法，用来获得第一个元素，NEXT（）方法：获得下一个元素。hasNext()方法用来判断是否有下一个元素，currentItem()方法：当前元素。
2、ConcreteIterator:具体迭代类，实现了父类的具体方法。并且在迭代的时候其实是一个游标在指向当前的元素的位置，通常标识的位置是一个非负整数。
3、Aggregate:抽象聚合类，用于存储具体的元素。并且声明了创建游标的方法。
4、ConcreteAggregate:具体聚合类，实现了父类的方法。并且创建了一个具体的迭代器对象。
- 迭代器模式的实现
抽象聚合类： 包含了创建的迭代器的工厂方法模式.
package com.iterator;
import java.util.ArrayList;
import java.util.List;
/**
* @Author zhaoxin
* @Email [email protected]
* @Description //TODO
* @Date 2019/4/8
**/
public abstract class AbstractObjectList {
/**
* 创建一个object 的arraylist集合
*/
protected List<Object> list=new ArrayList<>();
public AbstractObjectList(List<Object> list){
this.list=list;
}
/**
* 添加方法
* @param o
*/
public void addObj(Object o){
list.add(o);
}
/**
* 删除方法
* @param o
*/
public void remove(Object o){
list.remove(o);
}
/**
* 获取list
* @return
*/
public List<Object> getList(){
return list;
}
/**
* 获取迭代器的工厂方法
* @return
*/
public abstract ProducteIterator createIterator();
}
抽象迭代器类 ： 正向和反向两个遍历的方式。通过游标，其实就是数组的下标类似。来进行遍历。
package com.iterator;
/**
* @Author zhaoxin
* @Email [email protected]
* @Description //TODO
* @Date 2019/4/8
**/
public abstract class AbstractIterator {
/**
* 移到下一个元素
*/
public abstract void next();
/**
* 移到上一个元素
*/
public abstract void previous();
/**
* 获取上一个元素返回object
* @return
*/
public abstract Object getPrevious();
/**
* 获取下一个元素放回OBJECT
* @return
*/
public abstract Object getNext();
/**
* 是否是最后一个元素boolean
* @return
*/
public abstract boolean isNext();
/**
* 是否是第一个元素
* @return
*/
public abstract boolean isFrist();
}
具体聚合类：实现父类的方法，其次工厂类指定的是我这次需要用到的迭代器。可以进行扩展！
package com.iterator;
import java.util.List;
/**
* @Author zhaoxin
* @Email [email protected]
* @Description //TODO
* @Date 2019/4/8
**/
public class ConcreteObjectList extends AbstractObjectList {
public ConcreteObjectList(List<Object> list) {
super(list);
}
@Override
public ProducteIterator createIterator() {
return new ProducteIterator(this);
}
}
具体迭代器类：这个里面有迭代所需要的方法，是核心类。
package com.iterator;
import java.util.ArrayList;
import java.util.List;
/**
* @Author zhaoxin
* @Email [email protected]
* @Description //TODO
* @Date 2019/4/8
**/
public class ProducteIterator extends AbstractIterator {
private List<Object> objectList=new ArrayList<>();
private int cursor1; //游标
private int cursor2; //游标2
public ProducteIterator(ConcreteObjectList obj) {
// TODO Auto-generated constructor stub
this.objectList=obj.getList();
cursor1=0;
cursor2=objectList.size()-1;
}
@Override
public void next() {
if (cursor1<objectList.size()){
cursor1++;
}
}
@Override
public void previous() {
if (cursor2>-1){
cursor2--;
}
}
@Override
public Object getPrevious() {
return objectList.get(cursor2);
}
@Override
public Object getNext() {
return objectList.get(cursor1);
}
@Override
public boolean isNext() {
return (cursor1==objectList.size());
}
@Override
public boolean isFrist() {
return (cursor2==-1);
}
}
客户端
package com.iterator;
import java.util.ArrayList;
import java.util.List;
/**
* @Author zhaoxin
* @Email [email protected]
* @Description //TODO
* @Date 2019/4/8
**/
public class Client {
public static void main(String[] args) {
List<Object> list=new ArrayList<Object>();
AbstractObjectList objectList=new ConcreteObjectList(list);
objectList.addObj("倚天剑");
objectList.addObj("屠龙刀");
objectList.addObj("断肠草");
objectList.addObj("葵花宝典");
objectList.addObj("还我漂漂拳");
AbstractIterator abstractIterator=objectList.createIterator();
System.out.println("正向遍历-----------------------------");
while(!abstractIterator.isNext()){
System.out.println(abstractIterator.getNext()+"\t\t");
abstractIterator.next();
}
System.out.println("反向遍历-----------------------------");
while(!abstractIterator.isFrist()){
System.out.println(abstractIterator.getPrevious()+"\t\t");
abstractIterator.previous();
}
}
}
- 优缺点
优点：
1.解耦，对象在JAVA中的迭代模式其实用的是COLLECTION继承了Iterator这个类。给自己提供了一个遍历器。我们通过自己进行创建遍历器，可以很方便。
2.遍历的算法可以通过自己来定义。还可以定义N多种算法进行遍历。
3.由于引入了抽象迭代器，所以我们进行扩展的时候会比较方便，不用修改源码。符合开闭原则。
缺点：
- 有利有弊，当你进行分离一个类能解决的功能的时候，就势必会增加系统类的数量！
- 设计抽象迭代器的时候比较困难，因为需要考虑以后的如何扩展
- 使用场景
- 需要为一个集合，（聚合对象）提供N种不同的遍历方式的时候。
- 为不同的聚合类，提供统一的遍历方法的接口的时候。