Java设计模式（18）：迭代器模式

最新推荐文章于 2024-10-24 16:51:24 发布

传说中的靖哥哥

最新推荐文章于 2024-10-24 16:51:24 发布

阅读量150

点赞数

分类专栏： Java设计模式文章标签： Java 设计模式 Java设计模式迭代器模式

本文链接：https://blog.csdn.net/u011976388/article/details/111404189

版权

Java设计模式专栏收录该内容

24 篇文章 1 订阅

订阅专栏

18，迭代器模式（Iterator）

18.1，问题引入_学校体系结构

在组合模式中引入了学校体系结构，并通过 List 集合对各个层级进行定义，可以很方便的对整个结构进行遍历
但是如果各个层级的下属部门集合不一定都是用 List 集合定义，而是通过 Set，array 或者其他自定义方式进行存储，那就没有一个统一的方式进行结构遍历
此时可以引入迭代器模式进行统一

18.2，基本介绍

迭代器模式（Iterator Pattern）是一种常用的设计模式，属于行为型模式
如果我们的集合是通过不同的方式实现的，如Java集合，数组或者自定义集合等，当客户需要遍历这些集合时理论上就需要使用多种遍历方式，而且还会暴露出数据结构的内部规则，此时可以使用迭代器模式进行统一处理
迭代器模式，提供了一种遍历集合的统一接口，用一致的方式遍历元素，不需要知道元素内部数据结构
迭代器模式在Java集合中应用较多

18.3，类图

在这里插入图片描述

Department：基础元素类，实体类
Iterator：顶层迭代器接口，取自 java.util.Iterator，不需要自行定义，直接从JDK中取即可
XXXCollegeIterator：具体迭代器类，对应每一个需要遍历的实体集合，重写迭代器方法，进行元素发现和元素获取
College：顶层集合类接口，定义自定义集合的基本方法，并提供统一的获取迭代器方式
XXXCollege：具体集合类，重写各自的迭代器获取方式，每一个集合类对应一个迭代器类，各自独立
PrintCollege：集合类的管理类，即List<List>，可以对集合类进行统一输出

18.4，代码实现

Department：实体类

package com.self.designmode.iterator;

/**
 * 基础部门对象, 迭代器模式的基础对象
 * @author PJ_ZHANG
 * @create 2020-12-11 17:24
 **/
public class Department {

    private String name;

    private String des;

    public Department(String name, String des) {
        this.name = name;
        this.des = des;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

}

Iterator：java.util.Iterator类

package java.util;

import java.util.function.Consumer;

public interface Iterator<E> {
    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> var1) {
        Objects.requireNonNull(var1);

        while(this.hasNext()) {
            var1.accept(this.next());
        }

    }
}

ComputerCollegeIterator：计算机学院迭代器类

package com.self.designmode.iterator;

import java.util.Iterator;

/**
 * 计算机学院迭代器
 * @author PJ_ZHANG
 * @create 2020-12-11 17:25
 **/
public class ComputerCollegeIterator implements Iterator {

    private Department[] departmentArr;

    private int index = 0;

    public ComputerCollegeIterator(Department[] departmentArr) {
        this.departmentArr = departmentArr;
    }

    @Override
    public boolean hasNext() {
        // 如果当前索引以后到最后了, 则条件不成立,返回false
        // 如果数组中有一个元素, 则index = 0 == 1 - 1 = 0, 成立, 可以取第0个
        // 此处if判断不严谨, 没有加数组长度, 说明问题即可
        if (index <= departmentArr.length - 1 && null != departmentArr[index]) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        // 取当前元素数据, 并推进索引位置
        return departmentArr[index++];
    }
}

InfoCollegeIterator：信息工程学院迭代器类

package com.self.designmode.iterator;

import java.util.Iterator;
import java.util.List;

/**
 * 信息工程学院迭代器
 * @author PJ_ZHANG
 * @create 2020-12-11 17:25
 **/
public class InfoCollegeIterator implements Iterator {

    private List<Department> lstDepartment;

    private int index = 0;

    public InfoCollegeIterator(List<Department> lstDepartment) {
        this.lstDepartment = lstDepartment;
    }

    @Override
    public boolean hasNext() {
        // 如果当前索引以后到最后了, 则条件不成立,返回false
        // 如果数组中有一个元素, 则index = 0 == 1 - 1 = 0, 成立, 可以取第0个
        if (index <= lstDepartment.size() - 1) {
            return true;
        }
        return false;
    }

    @Override
    public Object next() {
        // 取当前元素数据, 并推进索引位置
        return lstDepartment.get(index++);
    }
}

College：学院顶层接口

package com.self.designmode.iterator;

import java.util.Iterator;

/**
 * 学校顶层接口
 * @author PJ_ZHANG
 * @create 2020-12-11 17:30
 **/
public interface College {

    void addDepartment(Department department);

    Iterator iterator();

}

ComputerCollege：计算机学院

package com.self.designmode.iterator;

import java.util.Iterator;

/**
 * 计算机学院
 * @author PJ_ZHANG
 * @create 2020-12-11 17:31
 **/
public class ComputerCollege implements College {

    // 构造学院下专业集合
    private Department[] departmentArr;

    // 推进索引
    private int index = 0;

    public ComputerCollege() {
        departmentArr = new Department[5];
    }

    /**
     * 添加专业
     * @param department
     */
    @Override
    public void addDepartment(Department department) {
        departmentArr[index++] = department;
    }

    /**
     * 生成计算机学院遍历的迭代器,准备进行遍历
     * @return
     */
    @Override
    public Iterator iterator() {
        return new ComputerCollegeIterator(departmentArr);
    }
}

InfoCollege：信息工程学院

package com.self.designmode.iterator;

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

/**
 * 信息工程学院
 * @author PJ_ZHANG
 * @create 2020-12-11 17:31
 **/
public class InfoCollege implements College {

    // 构造学院下专业集合
    private List<Department> lstDepartment;

    public InfoCollege() {
        lstDepartment = new ArrayList<>(10);
    }

    /**
     * 添加专业
     * @param department
     */
    @Override
    public void addDepartment(Department department) {
        lstDepartment.add(department);
    }

    /**
     * 生成信息工程学院遍历的迭代器,准备进行遍历
     * @return
     */
    @Override
    public Iterator iterator() {
        return new InfoCollegeIterator(lstDepartment);
    }
}

PrintCollege：学院管理类

package com.self.designmode.iterator;

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

/**
 * 学院遍历类
 * @author PJ_ZHANG
 * @create 2020-12-11 17:35
 **/
public class PrintCollege {

    private List<College> lstCollege = new ArrayList<>(10);

    /**
     * 添加学院对象
     * @param college
     */
    public void addCollege(College college) {
        lstCollege.add(college);
    }

    /**
     * 进行遍历
     */
    public void showCollege() {
        for (College college : lstCollege) {
            Iterator iterator = college.iterator();
            showIterator(iterator);
        }
    }

    public void showIterator(Iterator iterator) {
        for (;iterator.hasNext();) {
            Department department = (Department) iterator.next();
            System.out.println(department.getName());
        }
    }

}

Client：客户端

package com.self.designmode.iterator;

/**
 * 客户端, 进行执行
 * @author PJ_ZHANG
 * @create 2020-12-11 17:38
 **/
public class Client {

    public static void main(String[] args) {
        // 总体展示类
        PrintCollege printCollege = new PrintCollege();

        // 构建计算机学院
        ComputerCollege computerCollege = new ComputerCollege();
        computerCollege.addDepartment(new Department("Java专业", "Java专业"));

        // 构造信息工程学院
        InfoCollege infoCollege = new InfoCollege();
        infoCollege.addDepartment(new Department("信息工程", "信息工程"));

        // 添加学院
        printCollege.addCollege(computerCollege);
        printCollege.addCollege(infoCollege);
        // 展示
        // 注意: 计算机学院使用数组, 信息工程学院使用的是集合
        printCollege.showCollege();
    }

}

18.5，迭代器模式的注意事项和细节

提供了统一的元素遍历方式，客户端不用再考虑聚合的类型，通过统一的方式即可遍历
隐藏了聚合的内部结构，客户端进行遍历只能获取到迭代器，隐藏了内部构造
提供了一个设计思想，即一个类中只有一个引起变化的原因（单一职责原则）。在聚合类中，将迭代器分开，就是当管理对象集合和遍历对象集合分开。这样在集合改变的话，只影响聚合对象；遍历方式改变的话，只影响迭代器
当要展示一组相似对象，或者遍历一组相同对象时，需要使用到迭代器模式
缺点：每个聚合对象都需要一个迭代器，则过多的聚合对象势必面临过多的迭代器类，不方便管理。