介绍
迭代器模式（Iterator Pattern）又称游标模式（Cursor）模式，是行为型模式之一。迭代器模式源于对容器的访问，如Java中的List、Map、数组等，由于对容器的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对于容器来说就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外部提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个容器同时进行多个遍历操作，如果我们不提供遍历方法而让使用者自己趋势线，又会让容器内部细节暴露，所以迭代器模式应运而生，在客户访问类与容器体之间插入一个第三者——迭代器，很好地解决了上面的问题。
定义
提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。
使用场景
遍历一个对象时。
通用代码模板
//迭代器接口
public interface Iterator<T> {
//是否还有下一个元素
//@return true 表示有，false 表示没有
boolean hasNext();
//返回当前位置的元素并将位置移至下一位
T next();
}//具体迭代器类
public class ConcreteIterator<T> implements Iterator<T> {
private List<T> list = new ArrayList<T>();
private int cursor = 0;
public ConcreteIterator(List<T> list) {
this.list = list;
}
@Override
public boolean hasNext() {
return cursor != list.size();
}
@Override
public T next() {
T obj = null;
if(this.hasNext()) {
obj = this.list.get(cursor++);
}
return obj;
}
}//容器接口
public interface Aggregate<T> {
//添加一个元素
//@param obj 元素对象
void add(T obj);
//移除一个元素
//@param obj
void remove(T obj);
//获取容器的迭代器
//@return 迭代器对象
Iterator<T> iterator();
}//具体容器类
public class ConcreteAggregate<T> implements Aggregate<T> {
private List<T> list = new ArrayList<T>();
@Override
public void add(T obj) {
list.add(obj);
}
@Override
public void remove(T obj) {
list.remove(obj);
}
@Override
public Iterator<T> iterator() {
return new ConcreteIterator<T>(list);
}
}//客户类
public class Client {
public static void main(String[] args) {
Aggregate<String> a = new ConcreteAggregate<>();
a.add("Aige");
a.add("Studio\n");
a.add("SM");
a.add(" Brother");
Iterator<String> i = a.iterator();
while(i.hasNext()) {
System.out.print(i.next());
}
}
}角色介绍：
Iterator：迭代器接口。它负责定义、访问和遍历元素的接口。
Concrete Iterator：具体迭代器类。具体迭代器类的目的主要是实现迭代器接口，并记录遍历的当前位置。
Aggregate：容器接口。负责提供创建具体迭代器角色的接口。
Concrete Aggregate：具体容器类。具体迭代器角色与该容器相关联。
Client：客户类。
迭代器模式的简单实现
某公司需要统计两个事业部中，各自员工的数量，首先建一个实体类：
//员工实体类
public class Employee {
//姓名
private String name;
//年龄
private int age;
//性别
private String sex;
//职位
private String position;
public Employee(String name, int age, String sex, String position) {
this.name = name;
this.age = age;
this.sex = sex;
this.position = position;
}
@Override
public String toString() {
return "Employee{" + "name='" + name + '\'' +", age=" + age + ", sex=" + sex + ", position='" + position + '/'' + '}';
}
}为了简化代码，就不提供setter和getter方法了，下面是添加两个部门的人员信息：
首先添加第一个部门的人员信息：
public class CompanyMin {
private List<Employee> list = new ArrayList<>();
public CompanyMin() {
list.add(new Employee("小明", 27, "男", "程序员"));
list.add(new Employee("小云", 21, "女", "测试"));
list.add(new Employee("小芳", 24, "女", "测试"));
list.add(new Employee("可儿", 18, "女", "设计"));
list.add(new Employee("晴朗", 29, "女", "设计"));
}
public List<Employee> getEmployees() {
return list;
}
}下面的类用于添加另一个部门的成员信息：
public class CompanyHui {
private Employee[] array = new Employee[3];
public CompanyHui() {
array[0] = new Employee("晖哥", 94, "男", "程序员");
array[1] = new Employee("小红", 98, "男", "程序员");
array[2] = new Employee("小辉", 88, "男", "程序员");
}
public Employee[] getEmployees() {
return array;
}
}可见两个部门采用了不同的内部实现方式，以添加成员信息，第一个部门使用的是一个List来存储人员信息，而第二个部门采用了一个数组，如果老板要查看这两个部门的人员信息就必须遍历两个容器：
//老板要查看两个部门的人员，需要依次遍历两个容器
public class Boss {
public static void main(String[] args) {
//遍历第一个部门的人员
CompanyMin min = new CompanyMin();
List minList = min.getEmployees();
for(int i = 0; i < minList.size(); ++i) {
System.out.println(minList.get(i).toString());
}
//遍历第二个部门的人员
CompanyHui hui = new CompanyHui();
Employee[] huiArray = hui.getEmployees();
for(int i = 0; i < huiArray.length; ++i) {
System.out.println(huiArray[i]);
}
}
}这样的遍历方式并没什么问题，但是如果还有其他部门采用了别的添加人员的方式，bane在Boss类中又需要增加一段遍历逻辑。这时候就可以使用迭代器模式：
首先需要定义一个迭代器接口：
public interface Interator {
//是否还有下一个元素
//@return true表示有，false表示没有
boolean hasNext();
//返回当前位置的元素，并将位置移至下一位
Object next();
}对于不同的部门，我们将分别创建一个对应的迭代器：
//第一个部门的迭代器
public class MinIterator implements Iterator {
private List<Employee> list;
private int position;
public MinIterator(List<Employee> list) {
this.list = list;
}
@Override
public boolean hasNext() {
return !(position > list.size() - 1 || list.get(position) == null);
}
@Override
public Object next() {
Employee e = list.get(position);
position++;
return e;
}
}
//第二个部门的迭代器
public class HuiIterator implements Iterator {
private Employee[] array;
private int position;
public HuiIterator(Employee[] array) {
this.array = array;
}
@Override
public boolean hasNext() {
return !(position > array.length - 1 || array[position] == null);
}
@Override
public Object next() {
Employee e = array[position];
position++;
return e;
}
}仿照至之前的模板，我们还需要定义一个容器类的接口，该接口包含一个返回容器迭代器的抽象方法：
public interface Company {
//返回一个迭代器对象
Interator iterator();
}接着，我们修改一下两个容器类使之实现容器接口，并返回对应的迭代器对象：
public class CompanyMin implements Company {
private List<Employee> list = new ArrayList<Employee>();
public CompanyMin() {
list.add(new Employee("小明", 27, "男", "程序员"));
list.add(new Employee("小云", 21, "女", "测试"));
list.add(new Employee("小芳", 24, "女", "测试"));
list.add(new Employee("可儿", 18, "女", "设计"));
list.add(new Employee("晴朗", 29, "女", "设计"));
}
public List<Employee> getEmployees() {
return list;
}
@Override
public Iterator iterator() {
return new MinIterator(list);
}
}
public class CompanyHui implements Company {
private Employee[] array = new Employee[3];
public CompanyHui() {
array[0] = new Employee("晖哥", 94, "男", "程序员");
array[1] = new Employee("小红", 98, "男", "程序员");
array[2] = new Employee("小辉", 88, "男", "程序员");
}
public Employee[] getEmployees() {
return array;
}
@Override
public Iterator iterator() {
return new HuiIterator(array);
}
}最后，在Boss类中查看两个部门的人员信息将变得非常简单：
public class Boss {
public static void main(String[] args) {
CompanyMin min = new CompanyMin();
check(min.iterator());
CompanyHui hui = new CompanyHui();
check(hui.iterator());
}
public static void check(Iterator iterator) {
while(iterator.hasNext()) {
System.out.println(iterator.next().toString());
}
}
}总结
以上就是迭代器模式的应用。对于迭代器模式来说，优点是：支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系。而缺点是：对类文件的增加。
作者：vanpersie_9987 发表于2017/5/4 17:58:34 原文链接
阅读：17 评论：0 查看评论