第十四章、迭代器模式
迭代器模式，又叫做游标模式。是行为型设计模式之中的一个。我们知道对容器对象的訪问必定会涉及遍历算法。我们能够将遍历的方法封装在容器中，或者不提供遍历方法，让使用容器的人自己去实现去吧。
这两种情况好像都能够解决这个问题。
然而在前一种情况。容器承受了过多的功能。它不仅要负责自己“容器”内的元素维护（加入、删除等等），并且还要提供遍历自身的接口；并且因为遍历状态保存的问题，不能对同一个容器对象同一时候进行多个遍历。另外一种方式倒是省事，却又将容器的内部细节暴露无遗。
正因于此，迭代器模式应运而生。在客户訪问类与容器体之间插入一个第三者–迭代器，非常好的攻克了上述弊端。
1.定义
提供一种方法顺序訪问一个容器对象中的各个元素，而又不须要暴露该对象的内部表示。
2.使用场景
遍历一个容器对象时。
3.简单实现
用书中的样例：小民和小辉分别在公司两个事业部，某天老板安排任务让他们俩统计一下各自部门的员工数据。
员工实体类：
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) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.position = position;
}
// 简化代码，省略setter和getter方法
@Override
public String toString() {
return "Employee{" + "name='" + name + '\'' + ", age=" + age + ", sex="
+ sex + ", position='" + position + '\'' + "}";
}
}
小辉部门：
public class CompanyHui {
private Employee[] array = new Employee[3];
public CompanyHui(){
array[0] = new Employee("辉哥", 28, "男", "程序员");
array[1] = new Employee("小红", 23, "男", "程序员");
array[2] = new Employee("小辉", 25, "男", "程序员");
}
public Employee[] getEmployees(){
return array;
}
}小民部门：
public class CompanyMin {
private List<Employee> list = new ArrayList<>();
public CompanyMin(){
list.add(new Employee("小民", 26, "男", "程序员"));
list.add(new Employee("小芸", 22, "女", "測试"));
list.add(new Employee("小方", 18, "女", "測试"));
list.add(new Employee("可儿", 21, "女", "设计"));
list.add(new Employee("朗情", 19, "女", "设计")); //吐槽一下，为什么就小民一个男的，小辉部门全男的。
}
public List<Employee> getEmployees(){
return list;
}
}Boss查看：
public class Boss {
public static void main(String[] args) {
CompanyHui hui = new CompanyHui();
Employee[] huiList = hui.getEmployees();
for(int i = 0; i < huiList.length; i++){
System.out.println(huiList[i]);
}
CompanyMin min = new CompanyMin();
List minList = min.getEmployees();
for(int i = 0; i < minList.size(); i++){
System.out.println(minList.get(i).toString());
}
}
}
结果：
Employee{name='辉哥', age=28, sex=男, position='程序员'}
Employee{name='小红', age=23, sex=男, position='程序员'}
Employee{name='小辉', age=25, sex=男, position='程序员'}
Employee{name='小民', age=26, sex=男, position='程序员'}
Employee{name='小芸', age=22, sex=女, position='測试'}
Employee{name='小方', age=18, sex=女, position='測试'}
Employee{name='可儿', age=21, sex=女, position='设计'}
Employee{name='朗情', age=19, sex=女, position='设计'}这样看似也没有问题，可是假设有多个部门，每一个部门有各自的实现，那么我们就要在Boss类中添加一遍遍历逻辑，这样Boss类的功能会越来越多，同一时候暴露了内部细节。那么我们须要定义一个迭代器接口：
public interface Iterator {
/**
* 是否还有下一个元素
*
* @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 {
/**
* 返回一个迭代器对象
*
* @return 迭代器对象
*/
Iterator iterator();
}改动一下之前的两个容器类：
public class CompanyHui implements Company{
private Employee[] array = new Employee[3];
public CompanyHui(){
array[0] = new Employee("辉哥", 28, "男", "程序员");
array[1] = new Employee("小红", 23, "男", "程序员");
array[2] = new Employee("小辉", 25, "男", "程序员");
}
public Employee[] getEmployees(){
return array;
}
@Override
public Iterator iterator() {
return new HuiIterator(array);
}
}public class CompanyMin implements Company{
private List<Employee> list = new ArrayList<>();
public CompanyMin(){
list.add(new Employee("小民", 26, "男", "程序员"));
list.add(new Employee("小芸", 22, "女", "測试"));
list.add(new Employee("小方", 18, "女", "測试"));
list.add(new Employee("可儿", 21, "女", "设计"));
list.add(new Employee("朗情", 19, "女", "设计"));
}
public List<Employee> getEmployees(){
return list;
}
@Override
public Iterator iterator() {
return new MinIterator(list);
}
}Boss查看：
public class Boss {
public static void main(String[] args) {
CompanyHui hui = new CompanyHui();
check(hui.iterator());
CompanyMin min = new CompanyMin();
check(min.iterator());
}
private static void check(Iterator iterator){
while (iterator.hasNext()) {
System.out.println(iterator.next().toString());
}
}
}
结果不变，就不反复写了。
4.Android源代码中的模式实现
1.Cursor
当我们使用SQLiteDatabase的query方法查询数据库时。会返回一个Cursor游标对象，该游标的实质就是一个详细的迭代器，我们能够使用它来遍历数据库查询所得的结果集。
5.总结
迭代器模式发展至今。差点儿全部的高级语言都有对应的内置实现，对于开发人员而言，已经极少会自己去实现迭代器了，所以本章内容很多其它的是了解而非应用。
1.长处
（1）符合面向对象设计原则中的单一职责原则。
（2）支持对容器对象的多种遍历。弱化了容器类与遍历算法之间的关系。
2.缺点
（1）类文件的添加。
（3）会出现ConcurrentModificationException异常。
（2）遍历过程是一个单向且不可逆的遍历。