Java设计模式-迭代器模式

最近学习到设计模式，现总结个人学习迭代器模式内容【注重的是不同集合的统一遍历问题】。
上一篇：Java设计模式-访问者模式

定义

提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。（例如测试中的遍历方法，对List和Array的遍历）

优缺点

优点

• 访问一个聚合对象的内容而无需暴露它的内部表示
• 支持对聚合对象的多种遍历
• 单一责任原则
• 为遍历不同的聚合结构提供一个统一的接口

缺点

每一个聚合对象（如这里的用户）都要一个迭代器，会生成多个迭代器不便于管理，[如果添加一个房子对象，则需要创建对应的迭代器，迭代器会剧增不便于管理]

实现

迭代器模式的角色

• Iterator（迭代器）【如下的MyIterator】:迭代器定义访问和遍历元素的接口.
• ConcreteIterator 具体迭代器）:具体迭代器实现迭代器接口,对该聚合遍历时跟踪当前位置.
• Aggregate （聚合）:聚合定义创建相应迭代器对象的接口.
• ConcreteAggregate 具体聚合）【如下的刚需】：具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例.

代码

代码测试用到的对象

/**
 * 购房者
 * @author cc百川
 */
public class User {
	public String name;
	public String des;
	public User(String name, String des) {
		this.name = name; this.des = des;
	}
}

定义迭代器接口，以及具体的迭代器

/** 为了减少篇幅统一处理了格式，建议复制带或用格式刷统一处理一下 
 * 迭代器接口
 * @author cc百川
 */
public interface MyIterator {
	public abstract boolean hasNext();
    public abstract Object next();
}
/**
 * 刚需数组购房迭代器
 * @author cc百川
 */
class RigidDemandArrayIterator implements MyIterator{
	private User [] users;
	private int index; 
	public RigidDemandArrayIterator(User[] users) {
		this.users = users; this.index = 0;
	}
	@Override
	public boolean hasNext() {
		if(index<users.length && users!=null && users[index]!=null){ return true;
		} else { return false; }
	}
	@Override
	public Object next() { return  users[index++]; }	
}
/**
 * 刚需List集合户购房迭代器
 * @author cc百川
 */
class RigidDemandListIterator implements MyIterator{
	private List<User> users;
	private int index;
	//构造方法初始化数据
	public RigidDemandListIterator(List<User> users ) {
		this.users = users;		this.index = 0;
	}
	@Override //判断是否存在数据
	public boolean hasNext() {
		if(index<users.size() && users!=null && users.get(index)!=null){
			return true;
		} else {return false;}
	}
	@Override //获取数据
	public Object next() {return users.get(index++);}
}

集合接口以及相关实现类

/**
 * 集合接口统一定义了集合的行为
 * @author cc百川
 */
public interface Aggregate {
	public String getName();
	//增加用户的方法
	public void addUser(String name, String phone);
	//返回一个迭代器,遍历
	public MyIterator createIterator();
}
/**
 * 数组集合
 * @author cc百川
 */
class ArrayImpl implements Aggregate{
	private User [] users;
	private int index ;
	public ArrayImpl(User[] users) {
		this.users = users;index= 0;
	}
	public ArrayImpl(){this(new User[10]);}
	@Override
	public String getName() {return "数组方式的集合";}
	@Override
	public void addUser(String name, String des) {
		this.users[index++]=new User(name, des);
	}
	@Override
	public MyIterator createIterator() {return new RigidDemandArrayIterator(users);}
}
/**
 * List集合
 * @author cc百川
 */
class ListImpl implements Aggregate{
	private List<User> users; 
	//无参合有参构造方法
	public ListImpl(List<User> users) {
		this.users = users;  ;
	}
	public ListImpl(){this(new ArrayList<User>());}
	@Override //改方法仅用来测试
	public String getName() { return "list集合方式的集合"; }
	@Override //给集合添加元素
	public void addUser(String name, String des) {
		this.users.add(new User(name, des));
	}
	@Override //获取迭代器对象
	public MyIterator createIterator() {
		return new RigidDemandListIterator(this.users);
	}
}

测试

public class Test {
	public static void main(String[] args) {
		ArrayImpl rda = new ArrayImpl();
		System.out.println("======"+rda.getName()+"======");
		rda.addUser("孙悟空", "花果山被牛魔王占领了");
		rda.addUser("猪八戒", "高老庄孙悟空给毁了");
		rda.addUser("沙悟净", "流沙河转让了");
		
		MyIterator array =  rda.createIterator();
		while(array.hasNext()) {
			User user = (User) array.next();
			System.out.println("购房者是"+user.name+", 购房原因是："+user.des);
		}
		
		ListImpl rdl = new ListImpl();
		System.out.println("======"+rdl.getName()+"======");
		rdl.addUser("诸葛亮", "刘备请我去当军师，决定在成都购买套三，方便上下班");
		rdl.addUser("曹操", "因为我挟持了天子，给他买个房当门面，免得刘备说我不忠于汉室。");
		rdl.addUser("小乔", "战争年代小女子在乡下不容易，想买一个城里的房子");
		MyIterator list =  rdl.createIterator();
		while(list.hasNext()) {
			User user = (User) list.next();
			System.out.println("购房者是"+user.name+", 购房原因是："+user.des);
		}
	}
}

---

迭代器模式重点在于对不同集合的统一进行遍历。
以上仅为个人学习，如果错误望指出，谢谢。