设计模式学习第十六节 迭代器模式

概述

    1、迭代器模式主要是用于容器与容器的遍历，属于行为型模式。
    2、如果我们的集合元素使用不同的方式实现的，例如数组、Java集合类或者其它方式实现，当客户端需要遍历集合元素的时候，可能会需要多种遍历方式、而且还有可能暴露元素的内部结构，需要避免这些问题，可以考虑使用迭代器模式。
    3、迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素。不需要知道集合对象的底层表示，也就是不需要暴露内部的结构。
    类图简要示意

    类图简要说明
    1、Iterator接口，迭代器接口，主要提供hasNext、next、remove 等方法。
    2、ArrayIterator：具体的迭代器实现类，管理迭代器，
    3、Collection ：统一的集合接口，所有需要遍历的集合的父接口，
    4、MineArrayList : 具体的集合实现类，提供具体的迭代器实现方法和迭代器实例。

迭代器简单实现

    简单手写实现一个集合，并实现迭代器模式遍历该集合。
    代码实现如下：

package com.example.pattern.iterator;

/**
 * 迭代器模式 一般来说是专用的设计模式 用与容器与容器变量
 * Collection接口  MineArrayList 与MineLinkedList 接口
 * 自己实现一个容器 并实现遍历功能
 * 在物理层面上
 */
public interface MineCollection<E> {

    boolean add(E e); // 向容器中新增一个元素

    int size(); // 容器的元素个数

    MineIterator<E> iterator(); // 需要集合对象持有一个迭代器。
}

package com.example.pattern.iterator;

/**
 * 迭代器接口
 */
public interface MineIterator<E> { // 提供一个最简单迭代器

    boolean hasNext(); // 使用拥有下一个对象

    E next(); // 下一个对像的具体内容。

}

package com.example.pattern.iterator;

/**
 * 迭代器模式
 * 以数组形式存储元素  在物理层面上 划分出一连串的存储 是数组
 * 不连续的存储 第一块地址中有第二个地址的指向
 */
public class MineArrayList<E> implements MineCollection<E> {

    Object[] elements = new Object[10]; //存储元素的数组

    private int index = 0; // 当前数组的使用下标 也就是数组的长度


    @Override
    public boolean add(E e) {
        if (index == elements.length) { // 数组长度已经使用完 进行扩容
            Object[] newElements = new Object[elements.length * 2]; // 数组长度 * 2 动态扩容
            System.arraycopy(elements, 0, newElements, 0, elements.length);
            elements = newElements;
        }
        elements[index] = e;
        index++;
        return true;
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public MineIterator<E> iterator() { // 返回一个具体的迭代器对象
        return new MineArrayListIterator();
    }

    private class MineArrayListIterator implements MineIterator<E> { // 提供一个内部类具体实现迭代器的具体方法，简单实现，先不考虑别的线程或者其它方面的问题。
        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            return currentIndex < index;
        }

        @Override
        public E next() { // 下一个具体的元素
            Object element = elements[currentIndex];
            currentIndex++;
            return (E) element;
        }
    }
}

package com.example.pattern.iterator;

/**
 * 链表实现
 */
public class MineLinkedList<E> implements MineCollection<E> {

    Node<E> head = null; //头部节点
    Node<E> tail = null; // 尾部节点
    private int index = 0;

    @Override
    public boolean add(E e) {
        Node<E> t = tail; // 取出尾部元素
        Node<E> node = new Node<>(e);
        tail = node; //添加往尾部添加 作为最后一个元素
        if (t == null) {// 尾部节点为空 证明是第一次添加
            head = node;
        } else {
            t.next = node;
        }
        index++;

//        Node<E> node = new Node<>(e);
//        node.next = null;
//        if (head == null) {
//            head = node;
//            tail = node;
//        }
//        tail.next = node;
//        tail = node;
//        index++;
        return true;
    }

    @Override
    public int size() {
        return index;
    }

    @Override
    public MineIterator<E> iterator() {
        return new MineLinkedListIterator();
    }

    private static class Node<E> { //提供一个内部静态类 用与指向下存储元素的
        E item;
        Node<E> next; // 指向下一个元素的信息

        Node(E element) {
            this.item = element;
        }
    }

    private class MineLinkedListIterator implements MineIterator<E> {

        private Node<E> node = head;

        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            if (head == null) {
                return false;
            } else {
                return currentIndex < index;
            }
        }

        @Override
        public E next() {
            currentIndex++;
            if (null != node) {
                E item = node.item;
                node = node.next;
                return item;
            } else {
                return null;
            }

        }
    }

}

package com.example.pattern.iterator;

/**
 *客户端
 */
public class Client {

    public static void main(String[] args) {
        MineLinkedList<Integer> list = new MineLinkedList<>();
        for (int i = 0; i < 15; i++) {
            list.add(i);
        }
        System.out.println(list.toString());
        MineIterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

注意细节

    优点：
    1、迭代器模式：提供了一个统一的方法遍历对象，使用端不再考虑容器的类型，使用统一的方法就可以遍历容器对象。
    2、隐藏了容器的内部结构，客户端需要遍历容器的时候，只需要取到迭代器，而不需要知道容器的内部结构。
    3、提供了一种设计思想：就是一个类应该只有一个引起变化的原因（单一责任原则）。在容器类中，我们把迭代器分开，就是要把管理容器对象和遍历容器对象的职责分开，这样一来容器的变化，只会影响到容器对象，遍历的方式改变，只会影响到迭代器，各司其职。
    4、迭代器模式适用于容器与容器的遍历。
    缺点：
    1、每个容器对象都需要一个迭代器对象，增加类的复杂度与管理难度。