迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示.

 1.当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历时,就应该考虑用迭代器模式。
 2.当需要对聚集对象有多种遍历方式时，可以考虑用迭代器模式。
 3.迭代器模式在访问数组，集合，列表等数据时，尤其是数据库数据操作时，是非常普遍的应用，

    所以各种高级语言 都对它进行了封装，反而给人感觉此模式本身不太常用。

 

package Iterator;

//import java.awt.*;
import java.util.ArrayList;

/**
 * 迭代器抽象类
 */
abstract class Iterator {
 
 // 开始对象
 public abstract Object first();
 // 下一个对象
 public abstract Object next();
 // 当前对象
 public abstract Object currentItem();
 // 是否到结尾
 public abstract boolean isDone();
}
/**
 * 具体的聚集类，继承聚集抽象类Aggregate
 */
/**
 * 具体的迭代器类，继承迭代器抽象类Iterator
 */
class ConcreteIterator extends Iterator{
 
 // 定义一个具体的聚集对象
 private ConcreteAggregate aggregate;
 private int current =0 ;
 
 // 初始化时将具体的聚集对象传入
 public ConcreteIterator(ConcreteAggregate aggregate){
  this.aggregate =aggregate;
 }

 @Override
 public Object currentItem() {
  // 返回当前的聚集对象
  return aggregate.getItems().get(current);
 }

 @Override
 public Object first() {
  // 得到聚集的第一个对象
  return aggregate.getItems().get(0);
 }

 @Override
 public boolean isDone() {
  // 判断当前是否遍历到结尾，到结尾返回true
  return current>=aggregate.count()?true:false;
 }

 @Override
 public Object next() {
  
  // 得到聚集的下一个对象
  Object ref = null;
  current++;
  if(current<aggregate.count()){
   ref = aggregate.getItems().get(current);
  }
  return ref;
 }
}

/**
 * 聚集抽象类
 */
abstract class Aggregate {
 
 // 创建迭代器
 public abstract Iterator createIteraotr();

}

class ConcreteAggregate extends Aggregate{

 // 声明一个List泛型变量，用于存放聚合对象
 private ArrayList<Object> items = new ArrayList<Object>();
 @Override
 public Iterator createIteraotr() {  
  return new ConcreteIterator(this);
 }
 // 返回集合总个数
 public int count(){
  return items.size();
 }
 public ArrayList<Object> getItems() {
  return items;
 }
 public void setItems(ArrayList<Object> items) {
  this.items = items;
 }
}

/**
 * 反向遍历的具体的迭代器类，继承迭代器抽象类Iterator
 */
class ConcreteIteratorDesc extends Iterator{
 
 // 定义一个具体的聚集对象
 private ConcreteAggregate aggregate;
 private int current =0 ;
 
 // 初始化时将具体的聚集对象传入
 public ConcreteIteratorDesc(ConcreteAggregate aggregate){
  this.aggregate =aggregate;
  current = aggregate.count()-1;
 }

 @Override
 public Object currentItem() {
  // 返回当前的聚集对象
  return aggregate.getItems().get(current);
 }

 @Override
 public Object first() {
  // 得到聚集的第一个对象
  return aggregate.getItems().get(aggregate.count()-1);
 }

 @Override
 public boolean isDone() {
  // 判断当前是否遍历到结尾，到结尾返回true
  return current<0?true:false;
 }

 @Override
 public Object next() {
  
  // 得到聚集的下一个对象
  Object ref = null;
  current--;
  if(current>=0){
   ref = aggregate.getItems().get(current);
  }
  return ref;
 }
}

 

public class IteratorTest {
 
 public static void main(String[] args) {
  
  // 聚集对象（公交车）
  ConcreteAggregate a = new ConcreteAggregate();
  
  // 对象集合（新上来的乘客)
  ArrayList<Object> items = new ArrayList<Object>();
  items.add("大鸟");
  items.add("小菜");
  items.add("行李");
  items.add("老外");
  items.add("公交内部员工");
  items.add("小偷");  
  a.setItems(items);
  
  // 迭代器对象
  Iterator i = new ConcreteIterator(a);
  
  // 迭代器第一个对象（从第一个乘客开始)
  Object item = i.first();
  while(!i.isDone()){
   System.out.println(i.currentItem()+"请买车票");
   i.next();
  }
  System.out.println("------------反向遍历---------------");
  
  //-----反向遍历-------------------
  Iterator iDesc = new ConcreteIteratorDesc(a);
  // 迭代器第一个对象（从最后一个乘客开始)
  Object item2 = iDesc.first();
  while(!iDesc.isDone()){
   System.out.println(iDesc.currentItem()+"请买车票");
   iDesc.next();
  }
 }
}

 

转载：http://www.cnblogs.com/jqbird/archive/2011/08/31/2160653.html