JAVA设计模式之迭代器模式

一、迭代器模式简介

Iterator模式也叫迭代模式，是行为模式之一，它把对容器中包含的内部对象的访问委让给外部类，使用Iterator（遍历）按顺序进行遍历访问的设计模式。

二、迭代器模式的结构

三、迭代器模式的角色与职责

• Iterator（迭代器接口）：该接口必须定义实现迭代功能的最小定义方法集比如提供hasNext()和next()方法。
• ConcreteIterator（迭代器实现类）：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
• Aggregate（容器接口）：定义基本功能以及提供类似Iterator iterator()的方法。
• concreteAggregate（容器实现类）：容器接口的实现类。必须实现Iterator iterator()方法。

四、迭代器模式的具体实现

有一个餐厅和煎饼屋要合并，但是每个老板都只想用自己的菜单模式，餐厅使用的是数组形式的菜单，而煎饼屋使用的是ArrayList形式。
虽然实现形式不太一样，但是每个菜单项的内容是一样的，我们看一下菜单项的设计，比较常规的列出了名称、描述、是否是素食、价格：

// An highlighted block
package design.iterator.gys.noiterator;
public class MenuItem {
 String name;
 String desc;
 boolean vegetarian;
 double price;
 public MenuItem(String name, String desc, boolean vegetarian, double price) {
  super();
  this.name = name;
  this.desc = desc;
  this.vegetarian = vegetarian;
  this.price = price;
 }
 public String getName() {
  return name;
 }
 public String getDesc() {
  return desc;
 }
 public boolean isVegetarian() {
  return vegetarian;
 }
 public double getPrice() {
  return price;
 }
}

1、不使用迭代器模式

一开始老板们各执己见，不愿意更改自己的菜单，那我们就瞧一眼两个菜单吧。
餐厅：

// An highlighted block
package design.iterator.gys.noiterator;
public class DinnerMenu {
 static final int Max=6;
 int numberOfItem=0;
 MenuItem[] menu;
 public DinnerMenu() {
  menu=new MenuItem[Max];
  addItem("a2","b2",true,6.99);
  addItem("c2","d2",false,7.99);
  addItem("e2","f2",true,8.99);
  addItem("g2","h2",false,9.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  if(numberOfItem>=Max)
   System.out.println("menu is full");
  else
  {
   menu[numberOfItem]=mt;
   numberOfItem++;
  }
 }
 public MenuItem[] getMenu() {
  return menu;
 }
}

煎饼屋：

// An highlighted block
package design.iterator.gys.noiterator;
import java.util.ArrayList;
public class PancakeHouseMenu {
 ArrayList menu;
 public PancakeHouseMenu() {
  menu=new ArrayList();
  addItem("a1","b1",true,1.99);
  addItem("c1","d1",false,2.99);
  addItem("e1","f1",true,3.99);
  addItem("g1","h1",false,4.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  menu.add(mt);
 }
 public ArrayList getMenu() {
  return menu;
 }
}

果然风格迥异啊，这下可忙坏了服务员，得区分开两个菜单，不然一不小心可就要出洋相了。首先要取得菜单的形式，还都不一样，服务员需要对两者分别进行迭代：

// An highlighted block
package design.iterator.gys.noiterator;
import java.util.ArrayList;
public class Waitress {
 private PancakeHouseMenu menu1;
 private DinnerMenu menu2;
 public Waitress(PancakeHouseMenu menu1, DinnerMenu menu2) {
  super();
  this.menu1 = menu1;
  this.menu2 = menu2;
 }
 public void printMenu()
 {
  ArrayList breakfastMenu=menu1.getMenu();
  MenuItem[] lunchMenu=menu2.getMenu();
  System.out.println("***PancakeHouseMenu***");
  for(int i=0;i<breakfastMenu.size();i++)
   {
    MenuItem mt=(MenuItem)breakfastMenu.get(i);
    System.out.println(mt.getName()+" "+mt.getDesc()+" "+mt.getPrice());
   }
  System.out.println("***DinnerMenu***");
  for(int i=0;i<lunchMenu.length && lunchMenu[i]!=null;i++)
  {
   MenuItem mt=lunchMenu[i];
   System.out.println(mt.getName()+" "+mt.getDesc()+" "+mt.getPrice());
  }
 }
}

看看餐厅的运行情况：

// An highlighted block
package design.iterator.gys.noiterator;
public class Test {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  PancakeHouseMenu m=new PancakeHouseMenu();
  DinnerMenu d=new DinnerMenu();
  Waitress w=new Waitress(m, d);
  w.printMenu(); 
 }
}

// An highlighted block
***PancakeHouseMenu***
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
***DinnerMenu***
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99

很好，没出什么大的问题，服务员可算是尽心尽职的了。
那么问题来了，服务员需要两个循环来遍历菜单项，并且服务员和具体的菜单捆绑在一起，无法进行更多的功能扩展，并且两个菜单的内部实现完全暴露给了服务员，虽然我们不愿觉得他是坏人，但是万一呢。

2、使用迭代器模式

方案设计

类设计

为了减轻服务员的工作，让她只熟悉一个接口就能将所有的菜单打印出来。
首先我们对迭代器类进行抽象，但是仍然将菜单的内容留给厨师进行更改，并且在这里我们使用的是自定义的迭代器形式。

// An highlighted block
package design.iterator.gys.iterator;
public interface Iterator {
 public boolean hasNext();
 public Object next();
}

下面是餐厅迭代器的实现，由于菜单是数组类型，我们使用数组下标进行设计，由于是固定长度的数组，我们不仅要判断索引是否超过也要判断数组的内容是否为空：

// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class DinnerMenuIterator implements Iterator{
 private MenuItem[] menu;
 private int start=0;
 public DinnerMenuIterator(MenuItem[] menu) {
  super();
  this.menu = menu;
 }
 @Override
 public boolean hasNext() {
  // TODO Auto-generated method stub
  if(start<menu.length&&menu[start]!=null)
   return true;
  else
   return false;
 }
 @Override
 public Object next() {
  // TODO Auto-generated method stub
  return menu[start++];
 }
}

煎饼屋的菜单使用ArrlyList实现的，属于可变长度：

// An highlighted block
package design.iterator.gys.iterator;
import java.util.ArrayList;
public class PancakeHouseMenuIterator implements Iterator{
 private ArrayList menu;
 private int start=0;
 public PancakeHouseMenuIterator(ArrayList menu) {
  super();
  this.menu = menu;
 }
 @Override
 public boolean hasNext() {
  // TODO Auto-generated method stub
  if(start<menu.size())
   return true;
  else
   return false;
 }
 @Override
 public Object next() {
  // TODO Auto-generated method stub
  return menu.get(start++);
 }
}

至此，我们实现了两个菜单的迭代器。那么接下来我们就要在菜单内部进行处理，以便让服务员获得这个迭代器。
餐厅：

// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class DinnerMenu {
 static final int Max=6;
 int numberOfItem=0;
 MenuItem[] menu;
 public DinnerMenu() {
  menu=new MenuItem[Max];
  addItem("a2","b2",true,6.99);
  addItem("c2","d2",false,7.99);
  addItem("e2","f2",true,8.99);
  addItem("g2","h2",false,9.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  if(numberOfItem>=Max)
   System.out.println("menu is full");
  else
  {
   menu[numberOfItem]=mt;
   numberOfItem++;
  }
 }
 public Iterator createIterator() {
  return new DinnerMenuIterator(menu);
 }
}

煎饼屋：

// An highlighted block
package design.iterator.gys.iterator;
import java.util.ArrayList;
import design.iterator.gys.noiterator.MenuItem;
public class PancakeHouseMenu {
 ArrayList menu;
 public PancakeHouseMenu() {
  menu=new ArrayList();
  addItem("a1","b1",true,1.99);
  addItem("c1","d1",false,2.99);
  addItem("e1","f1",true,3.99);
  addItem("g1","h1",false,4.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  menu.add(mt);
 }
 public Iterator createIterator() {
  return new PancakeHouseMenuIterator(menu);
 }
}

看看新来的服务员适应如何:

// An highlighted block
package design.iterator.gys.iterator;
import design.iterator.gys.noiterator.MenuItem;
public class Waitress {
 PancakeHouseMenu menu1;
 DinnerMenu memu2;
 public Waitress(PancakeHouseMenu menu1, DinnerMenu memu2) {
  super();
  this.menu1 = menu1;
  this.memu2 = memu2;
 }
 public void printMenu() {
  Iterator i1=menu1.createIterator();
  printMenu(i1);
  System.out.println("----------");
  Iterator i2=memu2.createIterator();
  printMenu(i2);
 }
 public void printMenu(Iterator iterator)
 {
  while(iterator.hasNext()) {
   MenuItem m=(MenuItem)iterator.next();
   System.out.println(m.getName()+" "+m.getDesc()+" "+m.getPrice());
  } 
 }
}

So easy!现在服务员只需要调用每个菜单的迭代器，就能实现对菜单的遍历，不用再去了解内部的实现机制了。

// An highlighted block
package design.iterator.gys.iterator;
public class Tset {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  PancakeHouseMenu p=new PancakeHouseMenu();
  DinnerMenu d=new DinnerMenu();
  Waitress w=new Waitress(p, d);
  w.printMenu();
  System.out.println("**********");
  Iterator i=d.createIterator();
  w.printMenu(i);
 }
}

测试结果：

// An highlighted block
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
----------
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
**********
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99

效果不错，并且能单独对一个菜单进行输出了。

五、JAVA内置迭代器模式

1、Iterator接口

2、具体实现

方案设计

类设计

首先抽象出一个菜单类：

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.Iterator;
public interface Menu {
 public Iterator createIterator();
}

接着使用内置的迭代器进行类的设计。由于ArrlyList已经实现了接口，所以设计更为简便，先看煎饼屋的代码：

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.ArrayList;
import java.util.Iterator;
import design.iterator.gys.noiterator.MenuItem;
public class PancakeHouseMenu implements Menu{
 ArrayList menu;
 public PancakeHouseMenu() {
  menu=new ArrayList();
  addItem("a1","b1",true,1.99);
  addItem("c1","d1",false,2.99);
  addItem("e1","f1",true,3.99);
  addItem("g1","h1",false,4.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  menu.add(mt);
 }
 public Iterator createIterator() {
  return menu.listIterator();
 }
}

在这里我们直接调用的是listIterator()方法，会直接返回ArrayList的迭代器，可以直接使用。
但是由于数组不是类，无法实现内置的迭代器，我们需要自己实现餐厅迭代器的功能，但是不实现remove()功能，并且在调用的时候直接抛出异常。

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.Iterator;
import design.iterator.gys.noiterator.MenuItem;
public class DinnerMenuIterator implements Iterator{
 private MenuItem[] menu;
 private int start=0;
 public DinnerMenuIterator(MenuItem[] menu) {
  super();
  this.menu = menu;
 }
 @Override
 public boolean hasNext() {
  // TODO Auto-generated method stub
  if(start<menu.length&&menu[start]!=null)
   return true;
  else
   return false;
 }
 @Override
 public Object next() {
  // TODO Auto-generated method stub
  return menu[start++];
 }
 public void remove()
 {
  throw new UnsupportedOperationException();
 }
}

在DinnerMenu类中，我们只要导入util包中的迭代器即可，这里不再写出代码。
新的服务员到了，让我们看看他的能力：

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.Iterator;
import design.iterator.gys.noiterator.MenuItem;
public class Waitress {
 Menu menu1;
 Menu memu2;
 public Waitress(Menu menu1, Menu memu2) {
  super();
  this.menu1 = menu1;
  this.memu2 = memu2;
 }
 public void printMenu() {
  Iterator i1=menu1.createIterator();
  printMenu(i1);
  System.out.println("----------");
  Iterator i2=memu2.createIterator();
  printMenu(i2);
 }
 public void printMenu(Iterator iterator)
 {
  while(iterator.hasNext()) {
   MenuItem m=(MenuItem)iterator.next();
   System.out.println(m.getName()+" "+m.getDesc()+" "+m.getPrice());
  } 
 }
}

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.Iterator;
public class Test {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  PancakeHouseMenu p=new PancakeHouseMenu();
  DinnerMenu d=new DinnerMenu();
  Waitress w=new Waitress(p, d);
  w.printMenu();
  System.out.println("**********");
  Iterator i=d.createIterator();
  w.printMenu(i);
  System.out.println("**********");
  CoffeeMenu c=new CoffeeMenu();
  Iterator i2=c.createIterator();
  w.printMenu(i2);
 }
}

// An highlighted block
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
----------
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
**********
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
**********
i j 9.99
k l 10.99
m n 11.99
o p 12.99

现在又有一家咖啡厅要合并进来，先来看一下咖啡厅的菜单形式：

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.HashMap;
import java.util.Iterator;
import design.iterator.gys.noiterator.MenuItem;
public class CoffeeMenu implements Menu{
 private HashMap menu=new HashMap<>();
 public CoffeeMenu() {
  super();
  // TODO Auto-generated constructor stub
  addItem("i","j",true,9.99);
  addItem("k","l",false,10.99);
  addItem("m","n",true,11.99);
  addItem("o","p",false,12.99);
 }
 public void addItem(String name,String desc,boolean vegetarian,double price){
  MenuItem mt=new MenuItem(name, desc, vegetarian, price);
  menu.put(mt.getName(), mt);
 }
 @Override
 public Iterator createIterator() {
  // TODO Auto-generated method stub
  return menu.values().iterator();
 }
}

咖啡厅的菜单使用的是hashmap的组织形式，在实现了Menu接口之后，调用value().iterator()方法直接将值的迭代器传给服务员。
为了是服务员的功能进行扩展，我们对原先的代码进行改进，将内部的域实现为菜单集合的形式，通过迭代器来获取全部菜单。

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.ArrayList;
import java.util.Iterator;
import design.iterator.gys.noiterator.MenuItem;
public class Waitress2 {
 ArrayList menus=new ArrayList<>();
 public Waitress2(ArrayList menus) {
  super();
  this.menus = menus;
 }
 public void printMenu() {
  Iterator it=menus.iterator();
  while(it.hasNext()) {
   Menu menu=(Menu) it.next();
   printMenu(menu.createIterator());
   System.out.println("***********");
  }
 }
 public void printMenu(Iterator iterator)
 {
  while(iterator.hasNext()) {
   MenuItem m=(MenuItem)iterator.next();
   System.out.println(m.getName()+" "+m.getDesc()+" "+m.getPrice());
  } 
 }
}

在这里分为了两个步骤，第一步先获得菜单集合的迭代器，获取所有的菜单，再通过菜单的creatIterator()方法获取菜单的迭代器用来得到每个菜单项。
想必新的服务员已经急不可耐了。

// An highlighted block
package design.iterator.gys.inneriterator;
import java.util.ArrayList;
import java.util.Iterator;
public class Test2 {
 public static void main(String[] args) {
 ArrayList<Menu> menus=new ArrayList();
 menus.add(new PancakeHouseMenu());
 menus.add(new DinnerMenu());
 menus.add(new CoffeeMenu());
 Waitress2 w=new Waitress2(menus);
 w.printMenu();
 }
}

让我们来看看他的身手如何：

// An highlighted block
a1 b1 1.99
c1 d1 2.99
e1 f1 3.99
g1 h1 4.99
***********
a2 b2 6.99
c2 d2 7.99
e2 f2 8.99
g2 h2 9.99
***********
i j 9.99
k l 10.99
m n 11.99
o p 12.99
***********

不错，看来以后再有小餐厅合并进来，我们只需要让他的菜单实现Menu接口，并将其添加到服务员的菜单集合中就好了。
迭代器模式让我们能游走在聚合的每一个元素上，而不会暴露其内部的表示。

六、迭代器的优点

1. 不使用迭代器模式的应用

• 由容器自己实现顺序遍历。直接在容器类里直接添加顺序遍历方法
• 让调用者自己实现遍历。直接暴露数据细节给外部

2. 不使用迭代器的缺点

• 容器类承担了太多功能：一方面需要提供添加删除等本身应有的功能；一方面还需要提供遍历访问功能。
• 往往容器在实现遍历的过程中，需要保存遍历状态，当跟元素的添加删除等功能夹杂在一起，很容易引起混乱和程序运行错误等。

Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。所以，Iterator模式的应用场景可以归纳为满足以下几个
条件：

• 访问容器中包含的内部对象
• 按顺序访问

3. 迭代器模式的优点
   a)实现功能分离，简化容器接口。让容器只实现本身的基本功能，把迭代功能让给外部类实现，符合类的设计原则。
   b)隐藏容器的实现细节。
   c)为容器或其子容器提供了一个统一接口，一方面方便调用；另一方面使得调用者不必关注迭代器的实现细节。
   d)可以为容器或其子容器实现不同的迭代方法或多个迭代方法。

七、单一责任原则

原则： 一个类应该只有一个引起变化的原因。
有多个变化的原因，会很大程度引起将来类的改变，给类具有低内聚。相反，有高内聚的类更加易于维护。

要抱抱才会开心呀~~~~~~~~~~~~