迭代器模式笔记

迭代器模式笔记

定义

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

迭代器模式让我们能游走于聚合内的每一个元素，而又不暴露其内部的表示。把游走的任务放在迭代器上而不是聚合上。这样简化了聚合的接口和实现，每个类的分工更明确。

类图

例子

我们通过一个简单的例子了解迭代器模式，以及如何自定义迭代器模式。

 

package cn.lzz.hf.iterator;

/**
 * 自定义迭代器接口
 * @author Administrator
 *
 * @param <T>
 */
public interface Iterator<T> {
	/**
	 * @return
	 */
	T next();
	
	/**
	 * @return
	 */
	boolean hasNext();
}

package cn.lzz.hf.iterator;

/**
 * 菜单对象
 * @author Administrator
 *
 */
public class Menu {
	
	private String name;
	
	private double price;
	
	public Menu(){
		
	}
	public Menu(String name, double price) {
		super();
		this.name = name;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}
	@Override
	public String toString() {
		return "Menu [name=" + name + ", price=" + price + "]";
	}
	
	
}

package cn.lzz.hf.iterator;

/**
 * 数组菜单对象
 * @author Administrator
 *
 */
public class ArrayMenu {
	
	/**
	 * 菜单
	 */
	private Menu[] arrayMenu;
	
	private static final Integer MAX_SIZE=6;
	
	private Integer currnetIndex=0;
	
	public ArrayMenu(){
		 arrayMenu=new Menu[MAX_SIZE];
		 addMenuItem("馒头",1.0);
		 addMenuItem("包子",1.5);
	}
	private void addMenuItem(String name,double price){
		if(currnetIndex<MAX_SIZE){
			Menu tempMenu=new Menu(name,price);
			arrayMenu[currnetIndex++]=tempMenu;
		}
	}
	public Menu[] getArrayMenu() {
		return arrayMenu;
	}
	/**
	 * 创建迭代器
	 * @return
	 */
	public Iterator<Menu> createIterator(){
		return new ArrayIterator(arrayMenu);
	}
	
	/**
	 * 数组迭代器内部类
	 * @author Administrator
	 *
	 */
	private class ArrayIterator implements Iterator<Menu>{
		private Menu[] menus;
		
		private int position=0;
		
		public ArrayIterator( Menu[] menus){
			this.menus=ArrayMenu.this.arrayMenu;
		}
		
		@Override
		public Menu next() {
			// TODO Auto-generated method stub
			if(null!=menus && position<menus.length){
				return menus[position++];
			}
			return null;
		}

		@Override
		public boolean hasNext() {
			// TODO Auto-generated method stub
			if(null!=menus && position<menus.length 
					&& null!=menus[position]){
				return true;
			}
			return false;
		}
	}

}

package cn.lzz.hf.iterator;

import java.util.ArrayList;
import java.util.List;

/**
 * list菜单对象
 * @author Administrator
 *
 */
public class ListMenu {
	private List<Menu> menuList;
	public ListMenu(){
		menuList=new ArrayList<Menu>();
		 addMenuItem("馒头",1.0);
		 addMenuItem("包子",1.5);
	}
	private void addMenuItem(String name,double price){
		Menu tempMenu=new Menu(name,price);
		menuList.add(tempMenu);
	}
	public List<Menu> getMenuList() {
		return menuList;
	}
	
	public Iterator<Menu> createIterator(){
		return new ListIterator(menuList);
	}
	
}

package cn.lzz.hf.iterator;

import java.util.List;

/**
 * list迭代器
 * @author Administrator
 *
 */
public class ListIterator implements Iterator<Menu>{
	
	private List<Menu> menus;
	
	private int position=0;
	
	public ListIterator( List<Menu> menus){
		this.menus=menus;
	}
	
	@Override
	public Menu next() {
		// TODO Auto-generated method stub
		if(null!=menus && position<menus.size()){
			return menus.get(position++);
		}
		return null;
	}

	@Override
	public boolean hasNext() {
		// TODO Auto-generated method stub
		if(null!=menus && position<menus.size() 
				&& null!=menus.get(position)){
			return true;
		}
		return false;
	}

}

package cn.lzz.hf.iterator;

import java.util.List;

public class PrintTest {
	public static void main(String[] args) {
		ListMenu listMenu=new ListMenu();
		//List<Menu> menuList=listMenu.getMenuList();
		//printListMenu( menuList);
		ArrayMenu arrayMenu=new ArrayMenu();
		//Menu[] menuArray=arrayMenu.getArrayMenu();
		//printArrayMenu( menuArray);
		
		printIterator( listMenu.createIterator());
		System.out.println("-----------------------------------------");
		printIterator( arrayMenu.createIterator());
	}
	public static void printIterator(Iterator<Menu> iterator){
		if(null!=iterator){
			Menu menu=null;
			while(iterator.hasNext()){
				menu=iterator.next();
				System.out.println(menu);
			}
		}
	}
	public static void printListMenu(List<Menu> menuList){
		System.out.println("-----------List--------------------");
		for(int i=0;i<menuList.size();i++){
			System.out.println(menuList.get(i));
		}
	}
	public static void printArrayMenu(Menu[] menuArray){
		System.out.println("----------Array--------------------");
		for(int i=0;i<menuArray.length;i++){
			if(null!=menuArray[i]){
				System.out.println(menuArray[i]);
			}
			
		}
	}
}

Menu [name=馒头, price=1.0]
Menu [name=包子, price=1.5]
-----------------------------------------
Menu [name=馒头, price=1.0]
Menu [name=包子, price=1.5]

PrintTest对象的main方法中我们可以了解到，如果没有迭代器每一种集合都要写一个遍历方法会让代码变得冗余。使用迭代器只需要写一个循环就可以利用多态的特性遍历不同的集合。迭代器的实现可以定义成一个外部类，也可以定义在内部声明成一个内部类。或者也可以直接实现java API提供的迭代器接口。

在迭代器模式中，类的每个责任都有改变的潜在区域，超过一个责任就会有超过一个潜在的改变区域。因为修改代码会引发一些潜在的bug，如果一个类经常被修改引发潜在bug的几率就很大。所以尽量保证一个类只有一个引起变化的原因。

 多个迭代器访问的集合对象其实是同一份，在多线程的情况下，由于可能存在多个线程操作多个迭代器的同一份实例，如果需要做remove操作，需要特别注意。