Fork me on GitHub

设计模式之迭代器模式

发表于 | 分类于 |
本文共计: 2,358 | 阅读耗时 ≈ 11

设计模式之迭代器模式

1. 什么是迭代器模式

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

在应用Iterator模式之前，首先应该明白Iterator模式用来解决什么问题。或者说，如果不使用

Iterator模式，会存在什么问题：

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

以上方法1与方法2都可以实现对遍历，这样有问题呢？

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

迭代器模式的一般应用：

Iterator模式就是为了有效地处理按顺序进行遍历访问的一种设计模式，简单地说，Iterator模式提供一种有效的方法，可以屏蔽聚集对象集合的容器类的实现细节，而能对容器内包含的对象元素按顺序进行有效的遍历访问。

所以，Iterator模式的应用场景可以归纳为满足以下几个条件：

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

迭代器模式的结构：

1

  • Iterator（迭代器接口）：该接口必须定义实现迭代功能的最小定义方法集比如提供hasNext()和next()方法。这是所有的迭代器必须要实现的方法，可以使用java内置的Iterator也可以自己个性化定制
  • ConcreteIterator（迭代器实现类）：迭代器接口Iterator的实现类。可以根据具体情况加以实现。
  • Aggregate（容器接口）：定义基本功能以及提供类似Iterator iterator()的方法；
  • concreteAggregate（容器实现类）：容器接口的实现类。必须实现Iterator iterator()方法。

优点：

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

2.1具体实例

举一个具体的例子吧，xain’z现在有两家餐厅要合并，合并之后呢需要把菜单统一合并，形成一个统一的菜单，在打印的时候呢能够全部打印出来。

首先的设计想法呢就是每一个餐厅设计一个自己的菜单的类，但是自己在设计的时候使用的是不同的数据结构实现的这个菜单类，这样子的话其实在写一个专门的类似于打印的类，然后实例化两个餐厅然后打印出来。这样的话就是我要再合并一个餐厅的时候需要更改这个类。比较麻烦，所以我们就需要使用迭代器模式来设计这个项目。使用迭代器的话就很容易解耦餐厅和打印菜单之间的耦合关系。具体是怎么实现呢？

首先需要实现一个迭代器的接口：

1
2
3
4
5
public interface Iterator {
   
   public boolean hasNext();
   public Object next();
}

然后具体的类去扩展实现它：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
ublic class DinerMenu {
	private final static int Max_Items = 5;
	private int numberOfItems = 0;
	private MenuItem[] menuItems;

	public DinerMenu() {
		menuItems = new MenuItem[Max_Items];
		addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
		addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
		addItem("bean soup", "bean&potato salad", true, 3.28f);
		addItem("hotdog", "onions&cheese&bread", false, 3.05f);

	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		if (numberOfItems >= Max_Items) {
			System.err.println("sorry,menu is full!can not add another item");
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems++;
		}

	}

	public Iterator getIterator() {
		return new DinerIterator();
	}

	class DinerIterator implements Iterator {
		private int position;

		public DinerIterator() {
			position = 0;
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			if (position < numberOfItems) {
				return true;
			}
			
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuItem menuItem = menuItems[position];
			position++;
			return menuItem;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class CakeHouseMenu {
	private ArrayList<MenuItem> menuItems;
	
	
	public CakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		
		addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
		addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
		addItem("Stawberry Cake","fresh stawberry",true,3.29f);
		addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		menuItems.add(menuItem);
	}
	
	public Iterator getIterator()
	{
		return new CakeHouseIterator() ;
	}
	
	class CakeHouseIterator implements  Iterator
	 {		
		private int position=0;
		public CakeHouseIterator()
		{
			  position=0;
		}
		
		 	@Override
			public boolean hasNext() {
			// TODO Auto-generated method stub
			if(position<menuItems.size())
			{
				return true;
			}
			
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuItem menuItem =menuItems.get(position);
			position++;
			return menuItem;
		}};
	//其他功能代码	
}

最后就是具体的合并之后的打印类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class Waitress {
	private ArrayList<Iterator> iterators=new ArrayList<Iterator>();

	public Waitress() {
		
	}
	public void addIterator(Iterator iterator)
	{
		iterators.add(iterator);
		
	}
	public void printMenu() {
		Iterator iterator;
		MenuItem menuItem;
		for (int i = 0, len = iterators.size(); i < len; i++) {
			iterator = iterators.get(i);
			
			while(iterator.hasNext())
			{
				menuItem=(MenuItem)	iterator.next();
				System.out.println(menuItem.getName() + "***"
						+menuItem.getPrice()+"***"+ menuItem.getDescription());
			}
		}
	}

	public void printBreakfastMenu() {

	}

	public void printLunchMenu() {

	}

	public void printVegetableMenu() {

	}
}

测试类：

1
2
3
4
5
6
7
8
9
10
11
public class MainTest {
	public static void main(String[] args) {
		Waitress mWaitress=new Waitress();
		CakeHouseMenu mCakeHouseMenu = new CakeHouseMenu();
		DinerMenu	mDinerMenu = new DinerMenu();
		
		mWaitress.addIterator(mCakeHouseMenu.getIterator());
		mWaitress.addIterator(mDinerMenu.getIterator());
		mWaitress.printMenu();
	}
}

上面的方式其实是我们自己写了一个迭代器，其实java有内置的迭代器，我们用过collection的就知道，遍历的时候就是使用的Iterator。

上面的扩展实现Iterator的类使用java内置的Iterator怎么来做呢？

首先是： DinerMenu，因为他的菜单是数组实现的，没有内置的迭代器，所以还是需要我们自己继承内置的迭代器然后自己扩展实现一个。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class DinerMenu {
	private final static int Max_Items = 5;
	private int numberOfItems = 0;
	private MenuItem[] menuItems;
	
	public DinerMenu() {
		menuItems = new MenuItem[Max_Items];
		addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
		addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
		addItem("bean soup", "bean&potato salad", true, 3.28f);
		addItem("hotdog", "onions&cheese&bread", false, 3.05f);

	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		if (numberOfItems >= Max_Items) {
			System.err.println("sorry,menu is full!can not add another item");
		} else {
			menuItems[numberOfItems] = menuItem;
			numberOfItems++;
		}

	}

	public Iterator getIterator() {
		return new DinerIterator();
	}

	class DinerIterator implements Iterator {
		private int position = 0;

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			if (position < numberOfItems) {
				return true;
			}
			position = 0;
			return false;
		}

		@Override
		public Object next() {
			// TODO Auto-generated method stub
			MenuItem menuItem = menuItems[position];
			position++;
			return menuItem;
		}

		@Override
		public void remove() {
			// TODO Auto-generated method stub

		}

	}
}

CakeHouseMenu的菜单是由 ArrayList，java内的 ArrayList是有Iterator的直接使用就可以了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class CakeHouseMenu {
	private ArrayList<MenuItem> menuItems;
	private int position=0;
	public CakeHouseMenu() {
		menuItems = new ArrayList<MenuItem>();
		
		addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
		addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
		addItem("Stawberry Cake","fresh stawberry",true,3.29f);
		addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
	}

	private void addItem(String name, String description, boolean vegetable,
			float price) {
		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
		menuItems.add(menuItem);
	}
	

	
	public Iterator getIterator()
	{
		return menuItems.iterator();
	}
	//其他功能代码

	
}

看了上面的迭代器，之后next方法，那我要是访问前一个的时候怎么办，有没有previous的方法，当你自己个性化实现迭代器的时候是可以实现的，你添加两个方法，一个是获取前一个元素，一个是告诉你是否到达了最前面。然后Java的Collection FrameWork提供了另一种迭代器接口ListIterator,这个接口里面就是那个previous的方法，可以访问前一个元素。

3. 单一责任原则

单一责任原则就是：一个类应该只有一个引起变化的原因。

实现单一责任原则的话，在维护和修改代码的时候更加容易，因为每一个类只承担了一种责任，修改的该类的区域可能也就只有一组，但是很多种责任聚合在一块儿的话就修改的区域就会很多，并且你会感觉自己改的是乱起八糟的。

内聚是一个比单一责任原则更加普遍的概念，它用来度量一个类或模块紧密地达到单一目的或责任。当一个模块被设计的只支持一组相关功能的时候就是高内聚的，当被设计成支持一组不相关的功能的时候就是低内聚的。

本文标题:设计模式之迭代器模式

文章作者:WilsonSong

发布时间:2018年10月18日 - 14:10

最后更新:2018年10月18日 - 14:10

原始链接:https://songwell1024.github.io/2018/10/18/IteratorMode/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

-------------本文结束感谢您的阅读-------------