Java设计模式（七）—— 迭代器模式

        迭代器模式定义如下：提供一种方法访问一个容器对象中的各个元素，而又勿需暴露该对象的内部细节，是一种只应用于容器对象遍历的设计模式。

适合迭代器模式的情景如下：

• 遍历集合对象，不需要知道对象在集合中的存储方式
• 用户可以同时使用多个迭代器遍历一个集合

一、问题的提出

        在计算机程序设计中，经常会用到各种各样的容器，如数组、链表、集合、映射等。在容器的各种操作中，元素遍历时最常见的操作之一。不同类型的容器，遍历方法也不同。以学生数组和链表元素遍历功能为例，代码如下：

（1）学生类

public class Student {
    String sno;
    String name;

    public Student(String sno, String name) {
        this.sno = sno;
        this.name = name;
    }
}

（2）学生数组容器类

该类是泛型数组容器类，提供遍历功能的基础方法是：获得数组大小size()方法，获得数组某下标位置元素对象get()方法。

public class MyArray {
    T t[];
    //传入一个数组
    MyArray(T t[]) {
        this.t = t;
    }
    T get(int n) {
        if (n < t.length) {
            return t[n];
        } else {
            return null;
        }
    }
    int size() {
        return t.length;
    }
}

（3）链表节点类

        该类是任意泛型T的链表节点类，成员变量next代表指向的下一个Node节点的地址。

public class Node {
    T t;
    Node next;
    Node(T t) {
        this.t = t;
    }
    void setNext(Node next) {
        this.next = next;
    }
    Node getNext() {
        return next;
    }
    T getT() {
        return t;
    }
}

（4）链表容器类

        对链表容器来说，最重要的就是首元素，因此将其定义为成员变量head，getNext()方法是遍历链表最重要的基础方法，功能是返回形参节点node的后继节点。

public class MyLink {
    Node head;
    MyLink(Node head) {
        this.head = head;
    }

    public Node getHead() {
        return head;
    }
    Node getNext(Node node) {
        return node.getNext();
    }
}

（5）遍历数组及链表的测试类

public class Test {
    public static void main(String[] args) {
        System.out.println("数组测试：");
        //初始化一个学生数组
        Student s[] = new Student[2];
        s[0] = new Student("1001","zhangyin");
        s[1] = new Student("1002","siminmin");
        //将该学生数组传入MyArray
        MyArray myArray = new MyArray<>(s);
        for (int i = 0; i < myArray.size(); i++) {
            //返回数组下标对应的学生元素
            Student student = myArray.get(i);
            System.out.println(student.sno+"\t"+student.name);
        }
        System.out.println("链表测试：");
        //初始化另一个学生数组
        Student s1[] = new Student[3];
        s1[0] = new Student("1003","yinyin");
        s1[1] = new Student("1004","minmin");
        s1[2] = new Student("1005","sisi");
        //将每个学生元素放入node中
        Node node1 = new Node<>(s1[0]);
        Node node2 = new Node<>(s1[1]);
        Node node3 = new Node<>(s1[2]);
        node1.next = node2;
        node2.next = node3;

        MyLink myLink = new MyLink<>(node1);
        Node cur = myLink.getHead();
        while (cur != null) {
            Student student = cur.getT();
            System.out.println(student.sno+"\t"+student.name);
            cur = cur.getNext();
        }

    }
}

测试结果：

数组测试：
1001	zhangyin
1002	siminmin
链表测试：
1003	yinyin
1004	minmin
1005	sisi

思考：

从上面例子可以看出，数组和链表的遍历方式是不同的，那么能否有一种容器元素遍历方式，对各种容器而言都是一致的，且与容器的性质无关呢？这就用到迭代器遍历的思想。

二、迭代器模式

        迭代器模式，提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部元素的表示。迭代器模式把在元素之间游走的责任交给了迭代器，而不是聚合对象。

        JDK中迭代器模式是很成熟的，它应用在许多容器中，下面代码体现了迭代器在Vector、LinkedList、Set容器中的遍历应用，从中可以更清晰地看出迭代器的特点。

Vector容器的特点是内存空间是线性、连续的；

LinkedList容器的特点是链式结构；

Set容器的特点是树形结构

通过下面代码可以知道，容器元素的遍历与具体的容器是无关的。 

public class Test2 {

    public static void traverse(Collection collection) {
        Iterator it = collection.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }
    }

    public static void main(String[] args) {
        Vector vector = new Vector<>();
        vector.add("aaa");
        vector.add("bbb");
        vector.add("ccc");
        System.out.println("Vector traverse:");
        traverse(vector);
        System.out.println();

        LinkedList linkedList = new LinkedList<>();
        linkedList.add("ddd");
        linkedList.add("eee");
        linkedList.add("fff");
        System.out.println("LinkedList traverse:");
        traverse(linkedList);
        System.out.println();

        Set set = new HashSet<>();
        set.add("ggg");
        set.add("hhh");
        set.add("iii");
        System.out.println("Set traverse:");
        traverse(set);
        System.out.println();
    }
}

测试结果：

Vector traverse:
aaa
bbb
ccc

LinkedList traverse:
ddd
eee
fff

Set traverse:
ggg
iii
hhh