设计模式——迭代器模式

迭代器模式

迭代器模式（Iterator Pattern）：它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

迭代器是为容器服务的，迭代器模式就是为解决遍历这些容器中的元素而诞生的。都是目前已经是一个没落的模式，基本上没人会单独写一个迭代器，除非是产品性质的开发。

迭代器模式提供了遍历容器的方便性，容器只要管理增减元素就可以了，需要遍历时交由迭代器进行。

迭代器模式的角色：

• Iterator抽象迭代器：负责定义访问和遍历元素的接口，而且基本上是有固定的3个方法：first()获得第一个元素，next()访问下一个元素，isDone()是否已经访问到底部（Java叫做hasNext()方法）。
• ConcreteIterator具体迭代器：具体迭代器角色要实现迭代器接口，完成容器元素的遍历。
• Aggregate抽象容器：负责提供创建具体迭代器角色的接口，必然提供一个类似createIterator()的方法，在Java中一般是iterator()方法。
• Concrete Aggregate具体容器：具体容器实现容器接口定义的方法，创建出容纳迭代器的对象。

抽象迭代器Iterator：

public interface Iterator { 
    //遍历到下一个元素 
    public Object next(); 
    //是否已经遍历到尾部 
    public boolean hasNext(); 
    //删除当前指向的元素 
    public boolean remove(); 
}

具体迭代器ConcreteIterator：

public class ConcreteIterator implements Iterator { 
    private Vector vector = new Vector();
    //定义当前游标 
    public int cursor = 0; 
    @SuppressWarnings("unchecked") 
    public ConcreteIterator(Vector _vector){ 
        this.vector = _vector; 
    }
    //判断是否到达尾部 
    public boolean hasNext() { 
        if(this.cursor == this.vector.size()){ 
            return false; 
        }else{ 
            return true; 
        } 
    }
    //返回下一个元素 
    public Object next() { 
        Object result = null; 
        if(this.hasNext()){ 
            result = this.vector.get(this.cursor++); 
        }else{ 
            result = null; 
        }
        return result; 
    }
    //删除当前元素 
    public boolean remove() { 
        this.vector.remove(this.cursor); 
        return true; 
    } 
}

注意：开发系统时，迭代器的删除方法应该完成两个逻辑：一是删除当前元素，二是当前游标指向下一个元素。

抽象容器Aggregate：

public interface Aggregate { 
    //是容器必然有元素的增加 
    public void add(Object object); 
    //减少元素 
    public void remove(Object object); 
    //由迭代器来遍历所有的元素 
    public Iterator iterator(); 
}

具体容器ConcreteAggregate：

public class ConcreteAggregate implements Aggregate { 
    //容纳对象的容器 
    private Vector vector = new Vector(); 
    //增加一个元素 
    public void add(Object object) { 
        this.vector.add(object); 
    }
    //返回迭代器对象 
    public Iterator iterator() { 
        return new ConcreteIterator(this.vector); 
    }
    //删除一个元素 
    public void remove(Object object) { 
        this.remove(object); 
    } 
}

场景类Client：

public class Client { 
    public static void main(String[] args) { 
        //声明出容器 
        Aggregate agg = new ConcreteAggregate(); 
        //产生对象数据放进去 
        agg.add("abc"); 
        agg.add("aaa"); 
        agg.add("1234"); 
        //遍历一下 
        Iterator iterator = agg.iterator(); 
        while(iterator.hasNext()){ 
            System.out.println(iterator.next()); 
        } 
    } 
}

---

迭代器模式的应用

JDK 1.5中，Java把迭代器模式已经融入到基本API中。

java.util.Iterable的接口被如下类继承：BeanContext，BeanContextServices，BlockingQueue<E>，Collection<E>，List<E>，Queue<E>，Set<E>，SortedSet<E>。

java.util.Iterable的接口被如下类实现：AbstractCollection，AbstractList，AbstractQueue，AbstractSequentialList，AbstractSet，ArrayBlockingQueue，ArrayList，AttributeList，BeanContextServicesSupport，BeanContextSupport，ConcurrentLinkedQueue，CopyOnWriteArrayList，CopyOnWriteArraySet，DelayQueue，EnumSet，HashSet，JobStateReasons，LinkedBlockingQueue，LinkedHashSet，LinkedList，PriorityBlockingQueue，PriorityQueue，RoleList，RoleUnresolvedList，Stack，SynchronousQueue，TreeSet，Vector。

java.util.Iterable接口只有一个方法：iterator()。通过iterator()这个方法去遍历聚集类中的所有方法或属性，基本上现在所有的高级语言都有Iterator这个接口或者实现，Java已经把迭代器给我们准备好了，我们再去写迭代器，就有点多余了。所以，迭代器模式也有点没落了，基本上很少有项目再独立写迭代器，直接使用Collection下的实现类就可以完美地解决问题。

---

迭代器模式的实例

整理项目信息：现在有100多个还在开发或维护的项目，项目信息很乱，需要把这些项目最新情况重新打印一份，然后查看有什么问题。

（1）项目信息接口及实现

import java.util.Iterator;
public interface IProjectIterator extends Iterator {
}

import java.util.ArrayList;
import com.sfq.impl.IProject;
import com.sfq.impl.IProjectIterator;
public class ProjectIterator implements IProjectIterator {
	//所有的项目都放在ArrayList中
	private ArrayList<IProject> projectList = new ArrayList<IProject>();
	private int currentItem = 0;
	//传入projectList
	public ProjectIterator(ArrayList<IProject> projectList) {
		this.projectList = projectList;
	}
	//判断是否有元素
	@Override
	public boolean hasNext() {
		boolean b = true;
		if (this.currentItem >= projectList.size() || this.projectList.get(this.currentItem) == null) { 
			b = false;
		}
		return b;
	}
	//下一个值	
	@Override
	public IProject next() {
		return (IProject)this.projectList.get(this.currentItem ++);
	}
}

（2）项目迭代器接口及实现

public interface IProject {
	//增加项目
	public void add(String name,int num,int cost);
	//项目信息
	public String getProjectInfo();
	//迭代器
	public IProjectIterator iterator();
}

import com.sfq.impl.IProject;
import com.sfq.impl.IProjectIterator;
public class Project implements IProject {
	//定义项目列表
	private ArrayList<IProject> projectList = new ArrayList<IProject>();
	//项目名称
	private String name = "";
	//项目成员数量
	private int num = 0;
	//项目费用
	private int cost = 0;	
	public Project() {
	}
	//存储信息
	private Project(String name, int num, int cost) {
		this.name = name;
		this.num = num;
		this.cost = cost;
	}
	@Override
	public void add(String name, int num, int cost) {
		this.projectList.add(new Project(name,num,cost));
	}	
	@Override
	public String getProjectInfo() {
		String info = "";
		info = info + "项目名称是：" + this.name;
		info = info + "\t项目人数：" + this.num;
		info = info + "\t项目费用：" + this.cost;
		return info;
	}
	@Override
	public IProjectIterator iterator() {
		return new ProjectIterator(this.projectList);
	}
}

（3）场景类Client

import com.sfq.action.Project;
import com.sfq.impl.IProject;
import com.sfq.impl.IProjectIterator;
public class Boss {
	public static void main(String[] args) {
		//定义一个List，存放项目
		IProject project = new Project();
		//增加项目,这里就增加三个
		project.add("项目1", 10, 10000);
		project.add("项目2", 20, 20000);
		project.add("项目3", 30, 30000);
		//输出
		IProjectIterator projectIterator = project.iterator();
		while(projectIterator.hasNext()) {
			IProject p = (IProject)projectIterator.next();
			System.out.println(p.getProjectInfo());
		}
	}
}

当然存在更简单的方法，这里仅为学习迭代器模式。简单方法如类图，实现很简单，不再赘述。