java设计模式-迭代器模式

港控/mmm° 2022-05-28 13:27 245阅读 0赞

> 在计算机程序设计中，经常会用到各种各样的容器，如数组、链表、集合、映射等。在容器的各种操作中，元素遍历是最常见的操作之一，对不同类型的容器，遍历方法也不同,那么可不可以写一个统一的迭代器，让不同的容器都可以迭代呢，其实这个在JDK中的和集合中已经很常见了，我们可以自定义一个这样的迭代器。

**迭代器模式：**  
迭代器模式，提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部元素的表示，迭代器模式把再元素之间游走的责任交给了迭代器，而不是聚合对象，这不仅让聚合的接口和实现变得更简洁，也可以让聚合更专注在它所应该专注的事情，而不必理会遍历的事情。迭代主要是为容器而生。

**先看个JDK中的集合例子**

package com.madman.base.designMode.iteration;
    
    import java.sql.Connection;
    import java.util.*;
    
    public class Test{
        public static void main(String[] args) {
            Vector<String> v = new Vector<String>();
            v.add("l");
            v.add("g");
            v.add("b");
            LinkedList<String> l = new LinkedList<String>();
            l.add("c");
            l.add("u");
            l.add("a");
            traverse(v);
            System.out.println();
            traverse(l);
        }
    
        public static void traverse(Collection collection) {
            for (Iterator iterator = collection.iterator(); iterator.hasNext(); ) {
                Object next = iterator.next();
                System.out.println(next);
            }
        }
    }

Vector和LinkedList是两个完全不一样的容器，Vector容器的特点是内存空间是线性的，连续的，而LinkedList是链式结构，但是他们都使用traverse()方法，这就是迭代器的效果，通过迭代器可以遍历不同的容器，容器元素的遍历与容器本身没有什么关系，迭代器就是专门用来做迭代的事情的。

**迭代器的UML类图可以这样表示**  
![这里写图片描述][70]

#### 迭代器模式中涉及的角色有 ####

**Iterator（抽象迭代器）：**  
它定义了访问和遍历容器元素的接口，声明了用于遍历容器元素的方法。例如：用于判断是否还有下一个元素的hasNext()方法，用于访问下一个元素的next()方法。当然还可以定义其它方法，如获得首元素first()方法等。  
**ConcreteIterator（具体迭代器）：**  
它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。  
**Aggregate（抽象聚合类）：**  
它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。Aggregate与JDK中Collection接口相当。  
**ConcreteAggregate（具体聚合类）：**  
它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。ConcreteAggregate与JDK中各容器类Vector、LinkedList、HashSet相当。

#### 应用案例 ####

**MyIterator**

package com.madman.base.designMode.iteration;
    
    public interface MyIterator{
        Object next();
    
        boolean hasNext();
    }

**MyCollection**

package com.madman.base.designMode.iteration;
    
    public interface MyCollection{
        public void add(Object o);
    
        public int size();
    
        public MyIterator iterator();
    
        public MyIterator Reverseiterator();
    
    }

**MyArrayList**

package com.madman.base.designMode.iteration;
    
    import java.util.Arrays;
    
    public class MyArrayList implements MyCollection{ 
        //容器元素
        private Object[] elementData;
        //元素个数
        private int size;
    
        public MyArrayList(int size) {
            elementData = new Object[size];
            this.size = 0;
        }
    
        @Override
        public void add(Object o) {
            //容器添加元素
            if (this.size == elementData.length) {
                //容器扩容，并拷贝原数据
                int newSize = size * 2;
                elementData = Arrays.copyOf(elementData, newSize);
            }
            //添加新数据
            elementData[size] = o;
            size++;
        }
    
        //返回容器元素个数
        @Override
        public int size() {
            return size;
        }
    
        public Object get(int size) {
            return elementData[size];
        }
    
        //返回具体迭代器
        @Override
        public MyIterator iterator() {
            return new ArrayListIterator();
        }
    
        @Override
        public MyIterator Reverseiterator() {
            return new ReverseArrayListIterator();
        }
    
        private class ReverseArrayListIterator implements MyIterator{ 
            private int currentIndex = size;
    
            @Override
            public boolean hasNext() {
                if (currentIndex >= 0) {
                    return true;
                } else {
                    return false;
                }
            }
    
            @Override
            public Object next() {
                Object o = elementData[currentIndex];
                currentIndex--;
                return o;
            }
        }
    
        private class ArrayListIterator implements MyIterator{ 
            private int currentIndex = 0;
    
            @Override
            public boolean hasNext() {
                if (currentIndex >= size) {
                    return false;
                } else {
                    return true;
                }
            }
    
            @Override
            public Object next() {
                Object o = elementData[currentIndex];
                currentIndex++;
                return o;
            }
        }
    
    }

**MyLinkedList**

package com.madman.base.designMode.iteration;
    
    
    public class MyLinkedList implements MyCollection{ 
        //链表首节点
        private Node head = null;
        //链表容器元素个数
        private Node tail = null;
        //链表尾节点
        private int size = 0;
    
        //向链表容器添加元素
        @Override
        public void add(Object o) {
            //将o封装为链表节点对象
            Node node = new Node(o);
            //如果头结点为空，表明添加的是第一个节点
            if (head == null) {
                head = node;
                tail = node;
                node.setNext(null);
            } else {
                //设置后继节点
                tail.setNext(node);
                //设置tail值
                tail = node;
            }
            size++;
        }
    
        //返回链表容器元素个数
        @Override
        public int size() {
            return size;
        }
    
        //返回具体迭代器
        @Override
        public MyIterator iterator() {
            return new LinkedListIterator();
        }
    
        @Override
        public MyIterator Reverseiterator() {
            //单链表反转。。代码简单
            return null;
        }
    
        private class LinkedListIterator implements MyIterator{ 
            private Node currentNode = head;
    
            @Override
            public boolean hasNext() {
                if (currentNode == null) {
                    return false;
                } else {
                    return true;
                }
            }
    
            @Override
            public Object next() {
                Node node = currentNode;
                currentNode = currentNode.getNext();
                //返回当前节点元素值
                return node.getData();
            }
        }
    }

**Client**

package com.madman.base.designMode.iteration;
    
    import java.util.Collection;
    import java.util.Iterator;
    
    public class Client{
        public static void traverse(MyCollection c) {
            MyIterator it = c.iterator();
            while (it.hasNext()) {
                String s = (String) it.next();
                System.out.println(s);
            }
        }
    
        public static void Reversetraverse(MyCollection c) {
            MyIterator it = c.Reverseiterator();
            while (it.hasNext()) {
                String s = (String) it.next();
                System.out.println(s);
            }
        }
    
        public static void main(String[] args) {
            //初始化自定义数组容器
            MyCollection c = new MyArrayList(2);
            for (int i = 0; i < 20; i++) {
                c.add("array" + i);
            }
            System.out.println("数组容器遍历:");
            //遍历数组容器
            traverse(c);
            Reversetraverse(c);
            //初始化自定义链表容器
            MyCollection c2 = new MyLinkedList();
            for (int i = 0; i < 20; i++) {
                c2.add("link" + i);
            }
            System.out.println("链表容器遍历:");
            //遍历链表容器
            traverse(c2);
        }
    }

**结果**

数组容器遍历:
    array0
    array1
    array2
    array3
    array4
    array5
    array6
    array7
    array8
    array9
    array10
    array11
    array12
    array13
    array14
    array15
    array16
    array17
    array18
    array19
    null
    array19
    array18
    array17
    array16
    array15
    array14
    array13
    array12
    array11
    array10
    array9
    array8
    array7
    array6
    array5
    array4
    array3
    array2
    array1
    array0
    链表容器遍历:
    link0
    link1
    link2
    link3
    link4
    link5
    link6
    link7
    link8
    link9
    link10
    link11
    link12
    link13
    link14
    link15
    link16
    link17
    link18
    link19

迭代器模式还是比较好容易理解，并且JDK当中也有很多这样的案例，上面demo中的泛型处理的逻辑不严谨，单链表的反序也没有写，可以参考这种思想。关键点的就是容器都自定义了内部内并且内部类试下了MyIterator接口，成为对外的统一迭代口子。

[70]: /images/20220528/17181237c61b44da8a266b8eb96af4cd.png