《Android源码设计模式》之迭代器模式

迭代器模式介绍

迭代器模式(Iterator Pattern)又称为游标(Cursor) 模式，是行为型设计模式之一。我们对容器对象的访问必然会涉及遍历算法，如果我没将遍历方法封装到容器中，那么对于容器类来说就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个容器同时进行多个遍历操作，如果我们不提供遍历方法而让使用者自己去实现，又会让容器的内部细节暴露无遗，正因如此，迭代器模式应运而生，在客户访问类与容器体之间插入了一个第三者----迭代器，很好的解决了上述弊端。

迭代器模式的定义

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

迭代器模式的使用场景

遍历一个容器对象时。

迭代器模式的UML类图

根据类图可以得出如下一个迭代器模式的通用模式代码。

迭代器接口

package com.guifa.iteratorpattern;

public interface Iterator<T> {
    /**
     * 是否还有下一个元素
     *
     * @return true表示有，false表示没有
     */
    boolean hasNext();

    /**
     * 返回当前位置的元素并将位置移至下一位
     *
     * @return T
     */
    T next();
}

具体迭代器类

package com.guifa.iteratorpattern;

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

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;
    }
}

容器接口

package com.guifa.iteratorpattern;

public interface Aggregate<T> {

    /**
     * 添加一个元素
     *
     * @param obj 元素对象
     */
    void add(T obj);

    /**
     * 移除一个元素
     *
     * @param obj 元素对象
     */
    void remove(T obj);

    /**
     * 获取容器的迭代器
     *
     * @return 迭代器对象
     */
    Iterator<T> iterator();
}

具体容器类

package com.guifa.iteratorpattern;

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

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);
    }
}

客户类

package com.guifa.iteratorpattern;

public class Client {
    public static void main(String[] args) {
        Aggregate<String> a = new ConcreteAggregate<>();
        a.add("Tom");
        a.add("Studio\n");
        a.add("Lucy");
        a.add("Brother");
        Iterator<String> i = a.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
    }
}

角色介绍：
Iterator：迭代器接口，负责定义、访问和遍历元素的接口。
Concrete Iterator：具体迭代器类，目的主要是实现迭代器接口，并记录遍历的当前位置。
Aggregate：容器接口，负责提供创建具体迭代器角色的接口。
Concrete Aggregate：具体迭代器类，具体迭代器角色与该容器相关联。
Client：客户类。

迭代器模式的简单实现

小民和小辉分别在公司的两个事业部，某天老板安排任务让他们俩统计一下各自部门的员工数据，下面就先为员工创建一个实体类：

package com.guifa.iteratorpattern;

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 + '\'' +
                '}';
    }
}

接下来就是小米和小辉两个部门间人员数据的构建了，对于小民部门，小民创建了一个CompanyMin类来存储人员信息，为简化代码，这里只添加固定数据：

package com.guifa.iteratorpattern;

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

public class CompanyMin {

    private List<Employee> list = new ArrayList<>();

    public CompanyMin() {
        list.add(new Employee("小民", 29, "男", "程序员"));
        list.add(new Employee("小芸", 22, "女", "测试"));
        list.add(new Employee("小方", 18, "女", "测试"));
        list.add(new Employee("可儿", 21, "女", "设计师"));
        list.add(new Employee("朗晴", 23, "女", "设计师"));
    }

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

对于小辉，同样也创建了一个CompanyHui类来作为容器：

package com.guifa.iteratorpattern;

public class CompanyHui {

    private Employee[] array = new Employee[3];

    public CompanyHui() {
        array[0] = new Employee("辉哥", 29, "男", "程序员");
        array[1] = new Employee("小红", 22, "男", "程序员");
        array[2] = new Employee("小辉", 18, "男", "程序员");
    }

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

可见小民和小辉的内部实现使两种方式，小民的人员信息容器的内部实质是使用的一个List来存储人员信息，而小辉的实质上使用的是一个数组，如果老板要查看人员信息就必须遍历两个容器：

package com.guifa.iteratorpattern;

import java.util.List;

public class Boss {
    
    public static void main(String[] args) {
        CompanyMin min = new CompanyMin();
        List<Employee> minList = min.getEmployees();
        for (int i = 0; i < minList.size(); i++) {
            System.out.println(minList.get(i).toString());
        }

        CompanyHui hui = new CompanyHui();
        Employee[] huiList = hui.getEmployees();
        for (int j = 0; j < huiList.length; j++) {
            System.out.println(huiList[j]);
        }
    }
}

这样代码是没什么问题，需求也实现了，但是如果其他部分的人员信息也有各自不同的实现，那么对于每一个部门的信息容器我们都要在Boss类中增加一段遍历逻辑，这是很不科学的。这时候便可以使用迭代器实现，将遍历封装。首先我们定义个迭代器借口：

package com.guifa.iteratorpattern;

public interface Iterator {

    /**
     * 是否还有下一个元素
     *
     * @return true表示有，false表示没有
     */
    boolean hasNext();

    /**
     * 返回当前位置的元素，并将位置移至下一位
     *
     * @return 当前位置元素
     */
    Object next();
}

对于小民和小辉部门人员信息容器，我们分别创建一个对应的迭代器：

package com.guifa.iteratorpattern;

import java.util.List;

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;
    }
}

package com.guifa.iteratorpattern;

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;
    }
}

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

package com.guifa.iteratorpattern;

public interface Company {
    /**
     * 返回一个迭代器对象
     *
     * @return 迭代器对象
     */
    Iterator iterator();
}

这时我们修改一下两个容器类使之实现容器接口，并返回对应的迭代器对象：

package com.guifa.iteratorpattern;

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

public class CompanyMin implements Company{

    private List<Employee> list = new ArrayList<>();

    public CompanyMin() {
        list.add(new Employee("小民", 29, "男", "程序员"));
        list.add(new Employee("小芸", 22, "女", "测试"));
        list.add(new Employee("小方", 18, "女", "测试"));
        list.add(new Employee("可儿", 21, "女", "设计师"));
        list.add(new Employee("朗晴", 23, "女", "设计师"));
    }

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

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

package com.guifa.iteratorpattern;

public class CompanyHui implements Company {

    private Employee[] array = new Employee[3];

    public CompanyHui() {
        array[0] = new Employee("辉哥", 29, "男", "程序员");
        array[1] = new Employee("小红", 22, "男", "程序员");
        array[2] = new Employee("小辉", 18, "男", "程序员");
    }

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

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

最后在Boss类中查阅人员信息将变得更简单：

package com.guifa.iteratorpattern;

public class Boss {

    public static void main(String[] args) {
        CompanyMin min = new CompanyMin();
        check(min.iterator());

        CompanyHui hui = new CompanyHui();
        check(hui.iterator());
    }

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

输出结果如下：

总结

对于迭代器模式来说，其自身优点很明显也很单一，支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系，而其缺点就是对类文件的增加。