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

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

————————————————

原文链接：https://blog.csdn.net/qq_22118991/article/details/84968047