设计模式之迭代器模式

亦凉 2022-03-27 11:16 224阅读 0赞

# **定义** #

迭代器模式（Iterator Pattern）是常用的设计模式，属于行为型模式

如果我们的集合元素是用不同的方式实现的，有数组，还有java 的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。

迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70][]

迭代器模式的角色构成

(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),

(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。

(3)容器角色(Aggregate):  一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等

(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。

迭代器模式应用的场景及意义  
(1)访问一个聚合对象的内容而无需暴露它的内部表示

(2)支持对聚合对象的多种遍历

(3)为遍历不同的聚合结构提供一个统一的接口

实现一个迭代集合的功能

具体代码实现：

package com.dongguo.iterator;
    
    /**
     * @author Dongguo
     * @date 2021/8/22 0022-21:51
     * @description: 定义迭代器角色(Iterator)
     */
    public interface Iterator {
    
        public boolean hasNext();
        public Object next();
    }

定义具体迭代器角色(Concrete Iterator)

package com.dongguo.iterator;
    
    
    
    /**
     * @author Dongguo
     * @date 2021/8/22 0022-21:51
     * @description: 定义具体迭代器角色(Concrete Iterator)
     */
    
    
    public class ConcreteIterator implements Iterator {
        private List list = null;
        private int index;
    
        public ConcreteIterator(List list) {
            super();
            this.list = list;
        }
    
        @Override
        public boolean hasNext() {
            if (index >= list.getSize()) {
                return false;
            } else {
                return true;
            }
        }
    
        @Override
        public Object next() {
            Object object = list.get(index);
            index++;
            return object;
        }
    
    }

定义容器角色(Aggregate)

package com.dongguo.iterator;
    
    /**
     * @author Dongguo
     * @date 2021/8/22 0022-21:53
     * @description: 定义容器角色(Aggregate)
     */
    
    //定义集合可以进行的操作
    public interface List {
    
        public void add(Object obj);
        public Object get(int index);
        public Iterator iterator();
        public int getSize();
    }

定义具体容器角色(ConcreteAggregate)

package com.dongguo.iterator;
    
    /**
     * @author Dongguo
     * @date 2021/8/22 0022-21:54
     * @description: 定义具体容器角色(ConcreteAggregate)
     */
    
    public class ConcreteAggregate implements List{
    
        private Object[] list;
        private int size=0;
        private int index=0;
        public ConcreteAggregate(){
            index=0;
            size=0;
            list=new Object[100];
        }
        @Override
        public void add(Object obj) {
            list[index++]=obj;
            size++;
        }
    
        @Override
        public Iterator iterator() {
    
            return new ConcreteIterator(this);
        }
        @Override
        public Object get(int index) {
    
            return list[index];
        }
        @Override
        public int getSize() {
    
            return size;
        }
    
    }

代码测试

package com.dongguo.iterator;
    
    /**
     * @author Dongguo
     * @date 2021/8/22 0022-21:54
     * @description:
     */
    public class Client {
        public static void main(String[] args) {
    
            List list=new ConcreteAggregate();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            Iterator it=list.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }
    }
    运行结果：
    a
    b
    c
    d

# 迭代器模式在JDK-ArrayList 集合应用的源码分析  #

JDK 的ArrayList 集合中就使用了迭代器模式

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70 1][]

内部类Itr 充当具体实现迭代器Iterator 的类， 作为ArrayList 内部类

private class Itr implements Iterator<E> {
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such
            int expectedModCount = modCount;
    
            Itr() {}
    
            public boolean hasNext() {
                return cursor != size;
            }
    
            @SuppressWarnings("unchecked")
            public E next() {
                checkForComodification();
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length)
                    throw new ConcurrentModificationException();
                cursor = i + 1;
                return (E) elementData[lastRet = i];
            }
    
            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                checkForComodification();
    
                try {
                    ArrayList.this.remove(lastRet);
                    cursor = lastRet;
                    lastRet = -1;
                    expectedModCount = modCount;
                } catch (IndexOutOfBoundsException ex) {
                    throw new ConcurrentModificationException();
                }
            }
    
            @Override
            @SuppressWarnings("unchecked")
            public void forEachRemaining(Consumer<? super E> consumer) {
                Objects.requireNonNull(consumer);
                final int size = ArrayList.this.size;
                int i = cursor;
                if (i >= size) {
                    return;
                }
                final Object[] elementData = ArrayList.this.elementData;
                if (i >= elementData.length) {
                    throw new ConcurrentModificationException();
                }
                while (i != size && modCount == expectedModCount) {
                    consumer.accept((E) elementData[i++]);
                }
                // update once at end of iteration to reduce heap write traffic
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }
    
            final void checkForComodification() {
                if (modCount != expectedModCount)
                    throw new ConcurrentModificationException();
            }
        }

List 就是充当了聚合接口，含有一个iterator() 方法，返回一个迭代器对象

Iterator<E> iterator();

ArrayList 是实现聚合接口List 的子类，实现了iterator()

public Iterator<E> iterator() {
            return new Itr();
        }

Iterator 接口系统提供迭代器模式解决了不同集合(ArrayList ,LinkedList) 统一遍历问题

迭代器模式的优缺点：

迭代器模式的优点有：

*  简化了遍历方式，对于对象集合的遍历，还是比较麻烦的，对于数组或者有序列表，我们尚可以通过游标来取得，但用户需要在对集合了解很清楚的前提下，自行遍历对象，但是对于hash表来说，用户遍历起来就比较麻烦了。而引入了迭代器方法后，用户用起来就简单的多了。
 *  可以提供多种遍历方式，比如说对有序列表，我们可以根据需要提供正序遍历，倒序遍历两种迭代器，用户用起来只需要得到我们实现好的迭代器，就可以方便的对集合进行遍历了。
 *  封装性良好，用户只需要得到迭代器就可以遍历，而对于遍历算法则不用去关心。

迭代器模式的缺点：

*  对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐，大家可能都有感觉，像ArrayList，我们宁可愿意使用for循环和get方法来遍历集合。

总的来说：** 迭代器模式是与集合共生共死的，一般来说，我们只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的Collection，List、Set、Map等，这些集合都有自己的迭代器。假如我们要实现一个这样的新的容器，当然也需要引入迭代器模式，给我们的容器实现一个迭代器。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70]: /images/20220327/5ab027af42ee4aee84929e5a47b7c2a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70 1]: /images/20220327/104493076c504777b2a5582d90f0fbe3.png