设计模式之迭代器模式java实现代码

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

迭代器模式提供了一种方法，可以顺序访问一个聚合对象中的元素，而又不用知道内部是如何标示的。另外，迭代器模式把在元素之间游走的责任交给迭代器，而不是聚合对象，让聚合更专注于数据集合。

案例实现情景：我和友人去超市分头购物，在结帐时，我们遍历一下我们的 “扫货” 清单（遍历打印购物清单），在实现上，Me使用ArrayList，友人使用Thing[]数组，给遍历造成困扰。

案例代码：

Thing.java

public class Thing {
	private String name;
	private long price;
	public Thing(String name,long price){
		this.name = name;
		this.price = price;
	}
	@Override
	public String toString() {
		return "Thing [name=" + name + ", price=" + price + "]";
	}
	
}

Me.java

import java.util.ArrayList;
import java.util.Iterator;


public class Me {
	private ArrayList<Thing> shopping = new ArrayList<Thing>();
	
	public Me(){
		shopping.add(new Thing("巧克力", 35));
		shopping.add(new Thing("凉茶", 4));
		shopping.add(new Thing("袜子", 9));
		shopping.add(new Thing("香蕉", 12));
	}
	
	public Iterator<Thing> createIterator(){
		return shopping.iterator();
	}
}

Friends.java

import java.util.Iterator;


public class Friends {
	private Thing[] shopping = new Thing[100];
	
	public Friends(){
		shopping[0] = new Thing("牛奶",15);
		shopping[1] = new Thing("苹果",10);
		shopping[2] = new Thing("薯片",4);
	}
	
	public Iterator<Thing> createIterator(){
		return new ArrayIterator(shopping);
	}
}

ArrayIterator.java

import java.util.Iterator;


public class ArrayIterator implements Iterator<Thing>{
	private Thing[] thingArray;
	private int position = 0;
	public ArrayIterator(Thing[] array){
		thingArray = array;
	}
	
	@Override
	public boolean hasNext() {
		while(position<thingArray.length && thingArray[position] != null){
			return true;
		}
		return false;
	}

	@Override
	public Thing next() {
		return thingArray[position++];
	}

	@Override
	public void remove() {
		//noting to do 
	}

}

Test.java

import java.security.AllPermission;
import java.util.ArrayList;
import java.util.Iterator;


public class Test {
	public static void main(String args[]){
		ArrayList<Iterator<Thing>> allIterator = new ArrayList<Iterator<Thing>>();
		Me me = new Me();
		Friends friends = new Friends();
		
		Iterator<Thing> meIterator = me.createIterator();
		Iterator<Thing> friendsIterator = friends.createIterator();
		allIterator.add(meIterator);
		allIterator.add(friendsIterator);
		
		for(Iterator<Thing> iterator:allIterator){
			while(iterator.hasNext()){
				System.out.println(iterator.next());
			}
			System.out.println("---------------------");
		}
	}
}

测试结果：

Thing [name=巧克力, price=35]
Thing [name=凉茶, price=4]
Thing [name=袜子, price=9]
Thing [name=香蕉, price=12]
---------------------
Thing [name=牛奶, price=15]
Thing [name=苹果, price=10]
Thing [name=薯片, price=4]
---------------------

总结：

设计原则：

单一职责：一个类应该只有一个引起变化的职责。

当一个模块或一个类被设计成只支持一组相关的功能时，我们说它具有高内聚。