Java设计模式之——迭代器模式

迭代器模式简单介绍

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

迭代器的定义

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

迭代器模式的使用场景

遍历一个容器对象时。

迭代器模式的 UML 类图

角色介绍：

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

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

/**
 * 迭代器接口
 * @param <T>
 */
public interface Iterator<T> {

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

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

/**
 * 具体迭代器类
 * @param <T>
 */
public class ConcreteIterator<T> implements Iterator<T> {
    private List<T> list = new ArrayList<>();
    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;
    }
}

/**
 * 容器接口
 * @param <T>
 */
public interface Aggregate<T> {

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

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

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

/**
 * 具体容器类
 * @param <T>
 */
public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> list = new ArrayList<>();

    @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<>(list);
    }
}

/**
 * 客户端
 */
public class Client {
    public static void main() {
        Aggregate<String> a = new ConcreteAggregate<>();
        a.add("aKaiC");
        a.add("Android");
        a.add("IOS");
        Iterator<String> iterator = a.iterator();
        while (iterator.hasNext()) {
            Log.d("Client", iterator.next());
        }
    }
}

迭代器模式实战

举个例子：小明和小辉分别在公司的两个事业部，某天老板安排任务让他们俩统计一下各自部门的员工数据，这很好办嘛，建一个类用数据结构把所有员工数据存进去即可，老板要看的时候给他用 for 循环实现，还是比较容易的，下面就先为员工创建一个实体类：

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 方法了，接下来就是小明和小辉两个部门间人员数据的构建了，对于小明的部门，小明创建一个 CompanyMing 类来存储人员信息，这里为了简化代码，我们不提供对位添加人员信息的 add 方法，只在构造函数中添加固定数据：

public class CompanyMing {
    private List<Employee> list = new ArrayList<>();

    public CompanyMing() {
        list.add(new Employee("小民", 22, "男", "程序员"));
        list.add(new Employee("小芸", 26, "女", "测试"));
        list.add(new Employee("雪儿", 20, "女", "测试"));
        list.add(new Employee("小芳", 21, "女", "设计"));
    }

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

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

public class CompanyHui {
    public Employee[] array = new Employee[3];

    public CompanyHui() {
        array[0] = new Employee("辉哥", 28, "男", "程序员");
        array[1] = new Employee("晓峰", 20, "男", "程序员");
        array[2] = new Employee("小辉", 22, "男", "程序员");
    }

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

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

public class Boos {
    public static void main() {
        CompanyMing ming = new CompanyMing();
        List<Employee> employee = ming.getEmployee();
        for (int i = 0; i < employee.size(); i++) {
            //打印员工信息
        }

        CompanyHui hui = new CompanyHui();
        Employee[] employee1 = hui.getEmployee();
        for (int i = 0; i < employee1.length; i++) {
            //打印员工信息
        }
    }
}

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

/**
 * 迭代器接口
 * @param <T>
 */
public interface Iterator<T> {

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

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

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

public class MingIterator implements Iterator {
    private List<Employee> list;
    private int position;

    public MingIterator(List<Employee> list) {
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return position != list.size();
    }

    @Override
    public Object next() {
        return list.get(position++);
    }
}


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() {
        return array[position++];
    }
}

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

public interface Company {
    Iterator iterator();
}

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

public class CompanyMing implements Company {
    private List<Employee> list = new ArrayList<>();

    public CompanyMing() {
        list.add(new Employee("小民", 22, "男", "程序员"));
        list.add(new Employee("小芸", 26, "女", "测试"));
        list.add(new Employee("雪儿", 20, "女", "测试"));
        list.add(new Employee("小芳", 21, "女", "设计"));
    }

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

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

    public class CompanyHui implements Company {
    public Employee[] array = new Employee[3];

    public CompanyHui() {
        array[0] = new Employee("辉哥", 28, "男", "程序员");
        array[1] = new Employee("晓峰", 20, "男", "程序员");
        array[2] = new Employee("小辉", 22, "男", "程序员");
    }

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

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

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

public class Boos {
    public static void main() {
        CompanyMing ming = new CompanyMing();

        CompanyHui hui = new CompanyHui();

        check(ming.iterator());
        check(hui.iterator());
    }

    private static void check(Iterator iterator) {
        while (iterator.hasNext()) {
            Log.d("打印员工信息", iterator.next().toString());
        }
    }
}

具体的输出结果这里给出，大家可自行尝试。其实，在上述例子中只是做了一个假设，在所谓的自定义“容器”类中又使用了 Java 本身所提供的数据结构来存储数据，这也算是一种不恰当的实现方式，因为迭代器模式的规定不像其他模式那么严格，实现也因人而异，好在大部分高级语言的容器类都为我们提供了相应的迭代器而不需要开发者去手动实现。

总结

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

其实迭代器模式发展至今，几乎每一种高级语言都有相应的内置实现，对于开发者而言，已经极少会去由自己来实现迭代器了，因此，这里所介绍的内容只是为了让大家了解而非真正的去实际应用。