【设计模式（16）】行为型模式之迭代器模式

个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道

如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充

前言

学习c/c++的时候，有两种常用的数据存储结构——**链表 **& 数组，两种结构都提供了自己的遍历方法。

总所周知，常规意义上的数组是连续的内存结构，即整个数组的内存空间在一起，查找的时候可以从首地址往后找目标就行；

而链表是非连续的，每个节点存储本节点数据和下一个节点的地址，内存空间不要求连续，查找的时候从首节点，不断查询下一个节点，直到找到目标；

然而在实际开发中，根据六大设计原则（单一职责原则”和“开闭原则”），我们不应该暴露给用户具体的内部数据和遍历方法，而是只需要提供查询当前节点数据，和查询下一个节点的方法即可，这也就是迭代器出现的原因。

比如Java的Collection中就包括了迭代器，使其能够忽略数据类型和集合类型进行遍历。

现实中也有此类例子，比如办理手续，我们会从最开始的营业厅开始，一环一环的找工作人员办理，但是我们没必要知道整个流程的每个环节，也没必要非环节间的关系，只管知道现在这个流程该做啥和下一个流程找谁就行。

1.介绍

适用目的：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

主要解决：不同的方式来遍历整个整合对象。

何时使用：遍历一个聚合对象。

如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。

关键代码：定义接口：hasNext, next。

应用实例：JAVA 中的 iterator。

优点：

它支持以不同的方式遍历一个聚合对象。
迭代器简化了聚合类。
在同一个聚合上可以有多个遍历。
在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

使用场景：

访问一个聚合对象的内容而无须暴露它的内部表示。
需要为聚合对象提供多种遍历方式。
为遍历不同的聚合结构提供一个统一的接口。

注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

2.结构

è¿ä»£å¨æ¨¡å¼çç»æå¾

主要包括以下角色：

抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

3.实现步骤

定义抽象迭代器，定义数据遍历方法

//抽象迭代器
interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

定义迭代器，实现抽象迭代器

//具体迭代器
class ConcreteIterator implements Iterator {
    private List<Object> list = null;
    private int index = 0;

    public ConcreteIterator(List<Object> list) {
        this.list = list;
    }

    public boolean hasNext() {
        return list != null && index < list.size();
    }

    public Object first() {
        return list != null && list.size() > 0 ? list.get(0) : null;
    }

    public Object next() {
        return this.hasNext() ? list.get(index++) : null;
    }
}

这里选用list来存储数据，对外部匿名，实际上根据需求选用其他结构也可以

定义抽象聚合角色，定义数据存储和查询方法，并定义获取迭代器方法

//抽象聚合
interface Aggregate {
    void add(Object obj);

    void remove(Object obj);

    Iterator iterator();
}

定义具体聚合角色，实现抽象聚合角色

//具体聚合
class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<>();

    public void add(Object obj) {
        list.add(obj);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }

    public Iterator iterator() {
        return (new ConcreteIterator(list));
    }
}

同理，这里使用了list，可以根据需求改变成需要的结构

测试方法

public class IteratorPattern {
    public static void main(String[] args) {
        Aggregate ag = new ConcreteAggregate();
        ag.add("湖北");
        ag.add("湖南");
        ag.add("湖中间");
        Iterator iterator = ag.iterator();
        while (iterator.hasNext()) {
            Object ob = iterator.next();
            System.out.println(ob.toString());
        }

        ag.remove("湖南");
        Iterator iterator2 = ag.iterator();
        while (iterator2.hasNext()) {
            Object ob = iterator2.next();
            System.out.println(ob.toString());
        }
    }
}

运行结果

4.精简写法

上面的写法，其实很别扭的一点是在两个地方都定义了存储的结构，而且还得是一样的，反正我个人会抵触这种写法

在另一个地方看到的精简写法如下，但这样的耦合度更高

package com.company.designPattern.iteratorPattern2;

import java.util.ArrayList;
import java.util.List;

//抽象迭代器
interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

//抽象聚合
interface Aggregate {
    void add(Object obj);

    void remove(Object obj);

    Iterator iterator();
}

//具体聚合
class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<>();

    public void add(Object obj) {
        list.add(obj);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }

    public Iterator iterator() {
        return new ConcreteIterator();
    }

    //具体迭代器
    private class ConcreteIterator implements Iterator {
        int index = 0;

        public boolean hasNext() {
            return index < list.size();
        }

        public Object first() {
            return list.get(0);
        }

        public Object next() {
            return this.hasNext() ? list.get(index++) : null;
        }
    }
}

public class IteratorPattern2 {
    public static void main(String[] args) {
        Aggregate ag = new ConcreteAggregate();
        ag.add("湖北");
        ag.add("湖南");
        ag.add("湖中间");
        Iterator iterator = ag.iterator();
        while (iterator.hasNext()) {
            Object ob = iterator.next();
            System.out.println(ob.toString());
        }

        ag.remove("湖南");
        Iterator iterator2 = ag.iterator();
        while (iterator2.hasNext()) {
            Object ob = iterator2.next();
            System.out.println(ob.toString());
        }
    }
}

运行结果

5.扩展

与组合模式结合扩展

即使用迭代器替换掉组合模式中的存储和遍历方法

修改之前的组合模式demo，修改结果如下

package com.company.designPattern.iteratorPattern.test3;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

//抽象迭代器
interface Iterator {
    Object first();

    Object next();

    boolean hasNext();
}

//抽象聚合
interface Aggregate {
    void add(Object obj);

    void remove(Object obj);

    Iterator iterator();
}

@Data
class Employee implements Aggregate {
    private String name;
    private String dept;
    private int salary;

    // 加上static禁止被data注解提供直接访问方法
    private static List<Employee> list = new ArrayList<>();

    public Employee(String name, String dept, int salary) {
        this.name = name;
        this.dept = dept;
        this.salary = salary;
    }

    public String toString() {
        String subordinateNames = list.stream().map(Employee::getName).collect(Collectors.joining(", "));
        return ("Employee :[ "
                + "Name : " + name
                + ", dept : " + dept
                + ", salary : " + salary
                + ", subordinate : " + subordinateNames
                + " ]");
    }

    public void showCurrent() {
        System.out.println(this.toString());
    }

    public void showAll() {
        showCurrent();
        Iterator iterator = iterator();
        while (iterator.hasNext()) {
            ((Employee) iterator.next()).showAll();
        }
    }

    public void add(Object obj) {
        list.add((Employee) obj);
    }

    public void remove(Object obj) {
        list.remove(obj);
    }

    public Iterator iterator() {
        return new ConcreteIterator();
    }

    //具体迭代器
    private class ConcreteIterator implements Iterator {
        int index = 0;

        public boolean hasNext() {
            return index < list.size();
        }

        public Object first() {
            return list.get(0);
        }

        public Object next() {
            return this.hasNext() ? list.get(index++) : null;
        }
    }
}

public class CompositeAndIteratorTest {
    public static void main(String[] args) {
        Employee clerk1 = new Employee("clerk1", "clerk", 10000);
        Employee clerk2 = new Employee("clerk2", "clerk", 10000);

        Employee manager = new Employee("manager1", "manager", 50000);
        manager.add(clerk1);
        manager.add(clerk2);

        manager.showAll();
    }
}

运行结果

后记

迭代器的作用即隐藏数据的内部存储结构，而通过迭代器接口的方式，提供统一的访问和修改方法

从而一方面提高了数据的安全性，因为外部将无法直接访问数据本身

另一方面也降低了用户学习成本，毕竟只需要看迭代器提供的接口就行，并不需要关注数据的结构

作者：Echo_Ye

WX：Echo_YeZ

Email ：echo_yezi@qq.com

个人站点：在搭了在搭了。。。（右键 - 新建文件夹）

相关阅读:
java 日志体系
 java mail 接收邮件
 Spring 事物Transaction
Spring 文件上传MultipartFile 执行流程分析
 centos7安装Elasticsearch7
centos7安装docker笔记
 docker安装
 redis
springboot+redis+nginx+分布式session
tomcat程序和webapp分离
原文地址：https://www.cnblogs.com/silent-bug/p/14173890.html