8 行为型模式之

迭代器模式介绍：迭代器模式，又称为游标模式，是行为型模式之一。迭代器模式是一个比较古老的模式，其源于对容器的访问，比如Java中的List,Map，数组等，我们知道对容器的访问必然会涉及到遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法，如果我们将遍历的方法封装到容器中，那么对于容器类来说就承担了过多的功能，容器类不仅要维护自身内容的数据元素而且还要对外提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个pwkkk同时进行多个遍历操作，如果我们不提供遍历方法而让让使用者自己去实现，又会让容器的内部细节暴露无遗，正因于此，迭代模式应运而生，在客户访问类与容器之间插入了一个第三者--迭代器，很好地解决了上面的问题。

迭代器模式定义：提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。

迭代器使用场景：遍历一个容器对象时。

我们以小民和小辉分别在公司的两个事业部，某天老板安排任务让他们俩去统计一下各自部门的员工数，这很好办嘛，建一个类用来存储员工的数据，老板要看的时候他用for循环实现，还是比较容易的，下面就先为员工创建一个实体类：

/**
 * 员工实体类
 */
public class Employee {
    private String name;
    private int age;


    public Employee(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "name="+name+"  age="+age;
    }
}

对于小民部门，小创建了一个CompanyMin 类来存储人员信息，这里为了简化代码，我们不提供对外添加人员信息的add方法，只在构造函数中固定数据

/**
 * 小民部门
 */
public class CompanyMin implements Company {
    List<Employee> list = new ArrayList<>();

    public CompanyMin(){
        list.add(new Employee("xiaoA",33));
        list.add(new Employee("xiaoQ",34));
        list.add(new Employee("xiaoF",35));
        list.add(new Employee("xiaoG",36));
        list.add(new Employee("xiaoH",37));
    }

    public List<Employee> getList(){
        return list;
    }

    @Override
    public Iterator iterator() {
        return new MinIterator(list);
    }
}

对于小辉部门

/**
 * 小辉部门
 */
public class CompanyHui implements Company{
    private Employee[] employees = new Employee[3];

    public CompanyHui(){
        employees[0] = new Employee("tom",23);
        employees[1] = new Employee("jim",24);
        employees[2] = new Employee("tim",25);
    }

    public Employee[] getEmployees(){
        return employees;
    }

    @Override
    public Iterator iterator() {
        return new HuiIterator(employees);
    }
}

可见小民和小辉的内部实现是两种方式，小民的人员信息容器的内部用的是List，小辉的人员信息容器用的是Array，如果老板要查看人员信息就必须遍历两个容器。

代码如下：

/**
 * 一般的写法
 */
public class Boss {
    public static void main(String[] args){
        //遍历小民公司的员工
        CompanyMin min = new CompanyMin();
        List minList = min.getList();
        for (int i = 0;i<minList.size();i++){
            System.out.println(minList.get(i).toString());
        }

        //遍历小辉公司的员工 
        CompanyHui hui = new CompanyHui();
        Employee[] huiArr = hui.getEmployees();
        for (int i = 0;i<huiArr.length;i++){
            System.out.println(huiArr[i].toString());
        }
    }

}

这样的代码没有什么问题，老板也能查看到人员的信息，但是，这里要注意的是，如果其它部门的人员信息也有不同的实现，那么对于每一个部门的信息容器我们都要在Boss类中增加一段遍历代码，这是很不科学的，这时候可以用迭代器实现，将遍历逻辑封装，怎么做呢？首先我们需要定义一个迭代器接口：

/**
 * 迭代器接口
 */
public interface Iterator {

    //是否还有下一个元素
    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 employee = list.get(position);
        position++;

        return employee;
    }
}

小辉的迭代器

/**
 * 小辉部门的迭代器
 */
public class HuiIterator implements Iterator{
    private Employee[] employees;
    private int position;

    public HuiIterator(Employee[] employees){
        this.employees = employees;
    }

    @Override
    public boolean hasNext() {
        return !(position > employees.length - 1 || employees[position] == null);
    }

    @Override
    public Object next() {
        Employee e = employees[position];
        position++;

        return e;
    }
}

同时我们定义一个容器类的接口，在该接口中定义一个能够返回容器迭代器的方法：

/**
 * 接口
 */
public interface Company {

    //返回一个迭代器对象
    Iterator iterator();
}

两个部门分别实现容器接口，并返回对应的迭代器对象

/**
 * 小民部门
 */
public class CompanyMin implements Company {
    List<Employee> list = new ArrayList<>();

    public CompanyMin(){
        list.add(new Employee("xiaoA",33));
        list.add(new Employee("xiaoQ",34));
        list.add(new Employee("xiaoF",35));
        list.add(new Employee("xiaoG",36));
        list.add(new Employee("xiaoH",37));
    }

    public List<Employee> getList(){
        return list;
    }

    @Override
    public Iterator iterator() {
        return new MinIterator(list);
    }
}

/**
 * 小辉部门
 */
public class CompanyHui implements Company{
    private Employee[] employees = new Employee[3];

    public CompanyHui(){
        employees[0] = new Employee("tom",23);
        employees[1] = new Employee("jim",24);
        employees[2] = new Employee("tim",25);
    }

    public Employee[] getEmployees(){
        return employees;
    }

    @Override
    public Iterator iterator() {
        return new HuiIterator(employees);
    }
}

最后我们创建一个测试类，用来测试迭代器，代码如下：

/**
 * 迭代器测试类，相当于Boss
 */
public class IteratorTest {

    public static void main(String[] args){
        test();
    }

    public static void test(){
        CompanyMin companyMin = new CompanyMin();
        check(companyMin.iterator());

        CompanyHui companyHui = new CompanyHui();
        check(companyHui.iterator());

    }

    private static void check(Iterator iterator) {
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


}

输出结果如下：

name=xiaoA age=33
name=xiaoQ age=34
name=xiaoF age=35
name=xiaoG age=36
name=xiaoH age=37
name=tom age=23
name=jim age=24
name=tim age=25

好在Java容器类帮我们实现了迭代器。不需要我们自己去实现

迭代器模式用的很少，只是用在遍历容器的时候才用。