【设计模式——学习笔记】23种设计模式——迭代器模式Iterator(原理讲解+应用场景介绍+案例介绍+Java代码实现)

简介: 【设计模式——学习笔记】23种设计模式——迭代器模式Iterator(原理讲解+应用场景介绍+案例介绍+Java代码实现)

案例引入

编写程序展示一个学校院系结构: 需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系

【传统方式】

将学院看做是学校的子类,系是学院的子类,小的组织继承大的组织


分析: 在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个系, 因此这种方案,不能很好实现遍历操作(有可能计算机学院的系是使用数组存储的,信息工程学院的系是使用集合存储的,遍历的方式不太一样,因此不能统一遍历)


【改进】


使用迭代器模式

介绍

基础介绍

  • 迭代器模式属于行为型模式
  • 如果我们的元素集是用不同的方式实现,有数组、java的集合类或其他方式,当客户端要遍历这些元素集的元素的时就要使用多种遍历方式,而且还会暴露元素的内部结构,这时可以考虑使用迭代器模式解决
  • 迭代器模式提供一种遍历元素集元素的统一接口,用一致的方法遍历元素集的元素,不需要知道元素集对象的底层表示,即不需要暴露元素集对象内部的结构

应用场景

  • 当要展示一组相似对象,或者遍历一组相同对象时使用,适合使用迭代器模式

登场角色

  • lterator(迭代器): 该角色负责定义按顺序逐个遍历元素的接口(API),可以使用Java自带的,含有 hasNext、next、remove 等方法
  • Concretelterator(具体的迭代器):具体的选代器类,实现Iterator角色所定义的接口(API)
  • Aggregate(元素集):一个统一的元素集接口,将客户端和具体元素集解耦,定义了创建Iterator角色的接口(API)
  • ConcreteAggregate(具体的元素集): 负责实现Aggregate角色所定义的接口(API)。它会创建出具体的迭代器,即Concretelterator角色,该迭代器可以用于遍历元素集
  • Client(客户端):通过Iterator、Aggregate依赖其各自的子类

案例实现

案例一

实现

计算机学院迭代器】

package com.atguigu.iterator;
import java.util.Iterator;
public class ComputerCollegeIterator implements Iterator {
    /**
     * 这里我们需要Department是以怎样的方式存放(如果不知道,没办法重写Iterator的方法)=>已知计算机学院存放系的时候是数组耳朵方式
     */
    Department[] departments;
    /**
     * 遍历的位置
     */
    int position = 0;
    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }
    /**
     * 判断是否还有下一个元素
     * @return
     */
    @Override
    public boolean hasNext() {
        if (position >= departments.length || departments[position] == null) {
            return false;
        } else {
            return true;
        }
    }
    @Override
    public Object next() {
        Department department = departments[position];
        position += 1;
        return department;
    }
    /**
     * 删除的方法,默认空实现
     */
    public void remove() {
    }
}

【信息工程学院迭代器】

package com.atguigu.iterator;
import java.util.Iterator;
import java.util.List;
public class InfoColleageIterator implements Iterator {
    /**
     * 信息工程学院是以List方式存放系
     */
    List<Department> departmentList;
    /**
     * 索引
     */
    int index = 0;
    public InfoColleageIterator(List<Department> departmentList) {
        this.departmentList = departmentList;
    }
    /**
     * 判断list中还有没有下一个元素
     * @return
     */
    @Override
    public boolean hasNext() {
        if (index >= departmentList.size() - 1) {
            return false;
        } else {
            return true;
        }
    }
    @Override
    public Object next() {
        Department department = departmentList.get(index++);
        return department;
    }
    /**
     * 空实现remove
     */
    public void remove() {
    }
}

【学院接口】

package com.atguigu.iterator;
import java.util.Iterator;
public interface College {
    public String getName();
    /**
     * 增加系的方法
     *
     * @param name
     * @param desc
     */
    public void addDepartment(String name, String desc);
    /**
     * 返回一个迭代器来执行遍历功能
     *
     * @return
     */
    public Iterator createIterator();
}

【计算机学院】

package com.atguigu.iterator;
import java.util.Iterator;
public class ComputerCollege implements College {
    Department[] departments;
    /**
     * 保存当前数组的对象个数
     */
    int numOfDepartment = 0;
    public ComputerCollege() {
        departments = new Department[5];
        addDepartment("Java专业", " Java专业 ");
        addDepartment("PHP专业", " PHP专业 ");
        addDepartment("大数据专业", " 大数据专业 ");
    }
    @Override
    public String getName() {
        return "计算机学院";
    }
    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departments[numOfDepartment] = department;
        numOfDepartment += 1;
    }
    /**
     * 获取迭代器
     * @return
     */
    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}

【信息工程学院】

package com.atguigu.iterator;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class InfoCollege implements College {
   List<Department> departmentList;
   public InfoCollege() {
      departmentList = new ArrayList<Department>();
      addDepartment("信息安全专业", " 信息安全专业 ");
      addDepartment("网络安全专业", " 网络安全专业 ");
      addDepartment("服务器安全专业", "服务器安全专业 ");
   }
   @Override
   public String getName() {
      return "信息工程学院";
   }
   @Override
   public void addDepartment(String name, String desc) {
      Department department = new Department(name, desc);
      departmentList.add(department);
   }
   /**
    * 获取迭代器
    * @return
    */
   @Override
   public Iterator createIterator() {
      return new InfoColleageIterator(departmentList);
   }
}

【遍历输出类】

package com.atguigu.iterator;
import java.util.Iterator;
import java.util.List;
public class OutPutImpl {
    /**
     * 学院集合
     */
    List<College> collegeList;
    public OutPutImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }
    /**
     * 遍历所有学院,然后调用printDepartment 输出各个学院的系
     */
    public void printCollege() {
        //从collegeList 取出所有学院, Java 中的 List 已经实现Iterator
        Iterator<College> iterator = collegeList.iterator();
        while (iterator.hasNext()) {
            //取出一个学院
            College college = iterator.next();
            System.out.println("=== " + college.getName() + "=====");
            //得到学院的对应迭代器
            printDepartment(college.createIterator());
        }
    }
    /**
     * 使用学院的迭代器 输出学院的系
     * @param iterator
     */
    public void printDepartment(Iterator iterator) {
        while (iterator.hasNext()) {
            Department d = (Department) iterator.next();
            System.out.println(d.getName());
        }
    }
}

【主类】

package com.atguigu.iterator;
import java.util.ArrayList;
import java.util.List;
public class Client {
   public static void main(String[] args) {
      // 创建学院集合
      List<College> collegeList = new ArrayList<College>();
      // 添加学院
      ComputerCollege computerCollege = new ComputerCollege();
      InfoCollege infoCollege = new InfoCollege();
      collegeList.add(computerCollege);
      collegeList.add(infoCollege);
      OutPutImpl outPutImpl = new OutPutImpl(collegeList);
      outPutImpl.printCollege();
   }
}

【运行】

=== 计算机学院=====
Java专业
PHP专业
大数据专业
=== 信息工程学院=====
信息安全专业
网络安全专业
Process finished with exit code 0

案例二

实现

【Aggregate接口】

package com.atguigu.iterator.Sample;
/**
 * 要遍历的元素集的接口,实现这个接口的类一般可以保存多个元素
 */
public interface Aggregate {
    /**
     * 生成用于遍历的迭代器
     * @return
     */
    public abstract Iterator iterator();
}

【Iterator接口:可以直接使用JDK自带的,也可以自己直接写一个】

package com.atguigu.iterator.Sample;
public interface Iterator {
    /**
     * 是否有下一个元素
     * @return
     */
    public abstract boolean hasNext();
    /**
     * 获取下一个元素
     * @return
     */
    public abstract Object next();
}

【被存储的元素:Book】

package com.atguigu.iterator.Sample;
/**
 * 要存储的元素
 */
public class Book {
    private String name;
    public Book(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

【书架:具体的Aggregate】

package com.atguigu.iterator.Sample;
/**
 * 书架,存放书的元素集
 */
public class BookShelf implements Aggregate {
    // 不让外界直接操作书籍数组
    private Book[] books;
    private int last = 0;
    public BookShelf(int maxsize) {
        this.books = new Book[maxsize];
    }
    public Book getBookAt(int index) {
        return books[index];
    }
    public void appendBook(Book book) {
        this.books[last] = book;
        last++;
    }
    public int getLength() {
        return last;
    }
    public Iterator iterator() {
        // 返回书架的遍历迭代器
        return new BookShelfIterator(this);
    }
}

【书架遍历迭代器实现】

package com.atguigu.iterator.Sample;
public class BookShelfIterator implements Iterator {
    private BookShelf bookShelf;
    private int index;
    public BookShelfIterator(BookShelf bookShelf) {
        this.bookShelf = bookShelf;
        this.index = 0;
    }
    public boolean hasNext() {
        if (index < bookShelf.getLength()) {
            return true;
        } else {
            return false;
        }
    }
    public Object next() {
        Book book = bookShelf.getBookAt(index);
        // 取出下本书籍后,索引+1
        index++;
        return book;
    }
}

【主类】

package com.atguigu.iterator.Sample;
public class Main {
    public static void main(String[] args) {
        BookShelf bookShelf = new BookShelf(4);
        bookShelf.appendBook(new Book("Around the World in 80 Days"));
        bookShelf.appendBook(new Book("Bible"));
        bookShelf.appendBook(new Book("Cinderella"));
        bookShelf.appendBook(new Book("Daddy-Long-Legs"));
        // 获取书架的遍历迭代器
        Iterator it = bookShelf.iterator();
        // 开始遍历
        while (it.hasNext()) {
            Book book = (Book)it.next();
            System.out.println(book.getName());
        }
    }
}

【运行】

Around the World in 80 Days
Bible
Cinderella
Daddy-Long-Legs
Process finished with exit code 0

迭代器模式在JDK源码中的应用

  • lterator接口由系统提供
  • 内部类ltr充当具体实现迭代器Iterator的内部类
  • List充当了元素集接口,含有一个iterator() 方法,返回一个选代器对象
  • ArrayList 是实现元素集接口List的子类,实现了iterator()
  • 迭代器模式解决了不同元素集(ArrayList,LinkedList)的统一遍历问题

总结

【优点】

  • 提供一个统一的方法来遍历不同的元素集中的对象,客户不用再考虑元素集的类型,使用一种方法就可以遍历对象了
  • 隐藏了元素集的内部结构,客户端要遍历元素集的时候只能取到迭代器,而不会知道元素集的具体组成(比如说不知道使用什么数据结构存储的)
  • 提供了一种设计思想,就是一个类应该只有一个引起变化的原因 (叫做单一责任原则)。在元素集类中,我们把迭代器分开,就是要把管理元素集和遍历元素集的责任分开,这样一来元素集改变的话,只要修改元素集对象;而如果遍历方式改变的话,只要修改迭代器

【缺点】

  • 每个元素集对象都要一个迭代器,会生成多个选代器不好管理类

【思考】

问:为什么一定要考虑引人迭代器模式呢?如果是数组,直接使用for循环语句进行遍历处理不就可以了吗?

  • 引人Iterator后可以将遍历与元素集的实现分离开来。如果书架的实现方式不再使用数组存储,而是使用集合,那就只需要修改具体的迭代器和具体元素集即可,客户端并不需要修改,还是可以直接使用Iterator迭代器进行遍历
  • 方便实现多种不同的迭代方式,如正序遍历、倒序遍历、跳跃遍历……,想要拓展遍历方式,只需要给ConcreteAggregate编写新的ConcreteIterator即可,不需要修改元素集类的相关代码

文章说明

  • 本文章为本人学习尚硅谷的学习笔记,文章中大部分内容来源于尚硅谷视频(点击学习尚硅谷相关课程),也有部分内容来自于自己的思考,发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识,如有侵权请联系删除,最后对尚硅谷的优质课程表示感谢。
  • 本人还同步阅读《图解设计模式》书籍(图解设计模式/(日)结城浩著;杨文轩译–北京:人民邮电出版社,2017.1),进而综合两者的内容,让知识点更加全面
目录
相关文章
|
13天前
|
Java 编译器 数据库
Java 中的注解(Annotations):代码中的 “元数据” 魔法
Java注解是代码中的“元数据”标签,不直接参与业务逻辑,但在编译或运行时提供重要信息。本文介绍了注解的基础语法、内置注解的应用场景,以及如何自定义注解和结合AOP技术实现方法执行日志记录,展示了注解在提升代码质量、简化开发流程和增强程序功能方面的强大作用。
45 5
|
13天前
|
存储 算法 Java
Java 内存管理与优化:掌控堆与栈,雕琢高效代码
Java内存管理与优化是提升程序性能的关键。掌握堆与栈的运作机制,学习如何有效管理内存资源,雕琢出更加高效的代码,是每个Java开发者必备的技能。
42 5
|
15天前
|
Java API 开发者
Java中的Lambda表达式:简洁代码的利器####
本文探讨了Java中Lambda表达式的概念、用途及其在简化代码和提高开发效率方面的显著作用。通过具体实例,展示了Lambda表达式如何在Java 8及更高版本中替代传统的匿名内部类,使代码更加简洁易读。文章还简要介绍了Lambda表达式的语法和常见用法,帮助开发者更好地理解和应用这一强大的工具。 ####
|
12天前
|
安全 Java API
Java中的Lambda表达式:简化代码的现代魔法
在Java 8的发布中,Lambda表达式的引入无疑是一场编程范式的革命。它不仅让代码变得更加简洁,还使得函数式编程在Java中成为可能。本文将深入探讨Lambda表达式如何改变我们编写和维护Java代码的方式,以及它是如何提升我们编码效率的。
|
Java
Java中需要注意的一些案例
Java中需要注意的一些案例
120 0
|
14天前
|
设计模式 Java 开发者
Java多线程编程的陷阱与解决方案####
本文深入探讨了Java多线程编程中常见的问题及其解决策略。通过分析竞态条件、死锁、活锁等典型场景,并结合代码示例和实用技巧,帮助开发者有效避免这些陷阱,提升并发程序的稳定性和性能。 ####
|
12天前
|
存储 监控 小程序
Java中的线程池优化实践####
本文深入探讨了Java中线程池的工作原理,分析了常见的线程池类型及其适用场景,并通过实际案例展示了如何根据应用需求进行线程池的优化配置。文章首先介绍了线程池的基本概念和核心参数,随后详细阐述了几种常见的线程池实现(如FixedThreadPool、CachedThreadPool、ScheduledThreadPool等)的特点及使用场景。接着,通过一个电商系统订单处理的实际案例,分析了线程池参数设置不当导致的性能问题,并提出了相应的优化策略。最终,总结了线程池优化的最佳实践,旨在帮助开发者更好地利用Java线程池提升应用性能和稳定性。 ####
|
14天前
|
缓存 Java 开发者
Java多线程编程的陷阱与最佳实践####
本文深入探讨了Java多线程编程中常见的陷阱,如竞态条件、死锁和内存一致性错误,并提供了实用的避免策略。通过分析典型错误案例,本文旨在帮助开发者更好地理解和掌握多线程环境下的编程技巧,从而提升并发程序的稳定性和性能。 ####
|
8天前
|
安全 算法 Java
Java多线程编程中的陷阱与最佳实践####
本文探讨了Java多线程编程中常见的陷阱,并介绍了如何通过最佳实践来避免这些问题。我们将从基础概念入手,逐步深入到具体的代码示例,帮助开发者更好地理解和应用多线程技术。无论是初学者还是有经验的开发者,都能从中获得有价值的见解和建议。 ####