行为型设计模式——迭代器模式

这篇具有很好参考价值的文章主要介绍了行为型设计模式——迭代器模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

迭代器模式

迭代器模式也是非常的简单,定义如下: 提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。 相信大家都使用过类似下面的迭代器:

List<String> list = new ArrayList<>();
Iterator<String> iterator = list.iterator(); //list.iterator()方法返回的肯定是Iterator接口的子实现类对象
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

如果在你的项目中需要对一个自定义的集合进行迭代遍历,那么迭代器模式是非常需要学习的。迭代器模式主要包含以下角色:

  • 抽象聚合(Aggregate)角色:定义存储、添加、删除聚合元素以及创建迭代器对象的接口。

  • 具体聚合(ConcreteAggregate)角色:实现抽象聚合类,返回一个具体迭代器的实例。

  • 抽象迭代器(Iterator)角色:定义访问和遍历聚合元素的接口,通常包含 hasNext()、next() 等方法。

  • 具体迭代器(Concretelterator)角色:实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历,记录遍历的当前位置。

案例实现

【例】定义一个可以存储学生对象的容器对象,将遍历该容器的功能交由迭代器实现,涉及到的类如下:
行为型设计模式——迭代器模式,技术提升篇,设计模式,迭代器模式,Java迭代器模式,Java

代码如下

首先定义Student对象,如下:

public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后定义Student类迭代器接口,主要就判断是否还有下一个元素和获取下一个元素两个方法,如下:

public interface StudentIterator {
    boolean hasNext();
    Student next();
}

然后实现学生类迭代器接口就好,如下:

public class StudentIteratoirImpl implements StudentIterator{
    private List<Student> list;
    private int position = 0;

    public StudentIteratoirImpl(List<Student> list){
        this.list = list;
    }

    @Override
    public boolean hasNext() {
        return position<list.size();
    }

    @Override
    public Student next() {
        Student student = list.get(position);
        position++;
        return student;
    }
}

其实到这里我们就已经完成了迭代器功能了,可以使用下面的代码测试迭代器,如下:

public class Main {
    public static void main(String[] args) {

        // 测试迭代器类
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三",17));
        students.add(new Student("李四",19));
        students.add(new Student("王五",18));

        StudentIteratoirImpl iter = new StudentIteratoirImpl(students);
        while (iter.hasNext()){
            Student s = iter.next();
            System.out.println(s);
        }
    }
}

但是我们定义的是Student迭代器模型,上面的迭代器仅仅是实现了基础功能,如何需要的话我们可以将添加学生对象和删除学生对象的以及迭代的功能封装到一个容器类中,当然这部分内容属于扩展内容,如下:

// 定义学生容器接口
public interface StudentContainer {
    // 添加学生的操作
    void addStudent(Student student);
    // 移除学生
    void removeStudent(Student student);
    // 获取学生迭代器
    StudentIterator getStudentIterator();
}

// 实现学生容器接口
public class StudentContainerImpl implements StudentContainer{
    private List<Student> list = new ArrayList<Student>();
    @Override
    public void addStudent(Student student) {
        list.add(student);
    }

    @Override
    public void removeStudent(Student student) {
        list.remove(student);
    }

    @Override
    public StudentIterator getStudentIterator() {
        return new StudentIteratoirImpl(list);
    }
}

客户类测试:

public class Main {
    public static void main(String[] args) {

        // 测试迭代器类
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三",17));
        students.add(new Student("李四",19));
        students.add(new Student("王五",18));

        StudentIteratoirImpl iter = new StudentIteratoirImpl(students);
        while (iter.hasNext()){
            Student s = iter.next();
            System.out.println(s);
        }

        System.out.println("-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-");

        // 测试学生容器类
        StudentContainerImpl studentContainer = new StudentContainerImpl();
        studentContainer.addStudent(new Student("张三",17));
        studentContainer.addStudent(new Student("李四",19));
        studentContainer.addStudent(new Student("王五",18));
        StudentIterator studentIterator = studentContainer.getStudentIterator();
        while (studentIterator.hasNext()){
            Student s = studentIterator.next();
            System.out.println(s);
        }
    }
}

输出结果:

Student{name=‘张三’, age=17}
Student{name=‘李四’, age=19}
Student{name=‘王五’, age=18}
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Student{name=‘张三’, age=17}
Student{name=‘李四’, age=19}
Student{name=‘王五’, age=18}

优点

  • 它支持以不同的方式遍历一个聚合对象,在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法,我们也可以自己定义迭代器的子类以支持新的遍历方式。
  • 迭代器简化了聚合类。由于引入了迭代器,在原有的聚合对象中不需要再自行提供数据遍历等方法,这样可以简化聚合类的设计。
  • 在迭代器模式中,由于引入了抽象层,增加新的聚合类和迭代器类都很方便,无须修改原有代码,满足 “开闭原则” 的要求。

缺点

增加了类的个数,这在一定程度上增加了系统的复杂性。

使用场景

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

参考内容:

传智播客设计模式相关笔记(主要)文章来源地址https://www.toymoban.com/news/detail-801329.html

到了这里,关于行为型设计模式——迭代器模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 设计模式——迭代器模式

    迭代器模式 (Iterator Pattern) 是一种行为型设计模式, 它提供一种顺序访问聚合对象(如列表、集合等)中的元素,而无需暴露聚合对象的内部表示 。迭代器模式将遍历逻辑封装在一个 迭代器对象 中,使得我们可以使用统一的方式遍历不同类型的聚合对象,同时也可以简化客

    2024年02月16日
    浏览(37)
  • 【十五】设计模式~~~行为型模式~~~状态模式(Java)

    【学习难度:★★★☆☆,使用频率:★★★☆☆】 在很多情况下,一个对象的行为取决于一个或多个动态变化的属性,这样的属性叫做状态,这样的对象叫做有状态的(stateful)对象,这样的对象状态是从事先定义好的一系列值中取出的。当一个这样的对象与外部事件产生互

    2024年02月07日
    浏览(47)
  • 【Java 设计模式】行为型之状态模式

    状态模式(State Pattern)是一种行为型设计模式,用于通过将对象的行为封装到不同的状态类中,使得对象在不同的状态下具有不同的行为。状态模式允许对象在内部状态发生改变时改变其行为,而无需修改其代码。在本文中,我们将深入研究Java中状态模式的定义、结构、使

    2024年01月24日
    浏览(48)
  • 【Java 设计模式】行为型之命令模式

    命令模式(Command Pattern)是一种行为型设计模式,用于将请求封装为对象,使得可以参数化客户端对象,并且能够排队、记录请求,以及支持撤销操作。在本文中,我们将深入研究Java中命令模式的定义、结构、使用场景以及如何在实际开发中应用。 命令模式是一种行为型设

    2024年01月23日
    浏览(41)
  • 【Java 设计模式】行为型之责任链模式

    责任链模式(Chain of Responsibility Pattern)是一种行为型设计模式,用于将请求发送者和接收者解耦,使得多个对象都有机会处理请求。责任链模式通过创建一个处理请求的链,将请求沿着链传递,直到有一个对象能够处理为止。在本文中,我们将深入研究Java中责任链模式的定

    2024年01月24日
    浏览(48)
  • 【玩转23种Java设计模式】行为型模式篇:模板模式

    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 汇总目录链接:【玩转23种Java设计模式】学习目录汇总

    2024年02月16日
    浏览(36)
  • 【玩转23种Java设计模式】行为型模式篇:责任链模式

    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 汇总目录链接:【玩转23种Java设计模式】学习目录汇总

    2024年02月13日
    浏览(34)
  • Java设计模式之行为型-状态模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 五、总结 状态模式允许一个对象在其内部状态改变时改变它的行为,对象看起来似乎修改了它的类,状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况,把状态的判断逻辑转移到表示不

    2024年02月16日
    浏览(39)
  • Java设计模式之行为型-命令模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、基本实现 4.2、点餐案例  五、总结 1、将一个请求封装为一个对象,使您可以用不同的请求对客户进行参数化。 2、对请求排队或记录请求日志,以及支持可撤销的操作。 3、将命令对象与执行命令的对象分离,

    2024年02月16日
    浏览(35)
  • Java 设计者模式以及与Spring关系(七) 命令和迭代器模式

    本文是个系列一次会出两个设计者模式作用,如果有关联就三个,除此外还会讲解在spring中作用。 23设计者模式以及重点模式 我们都知道 设计者模式 有 3 类 23 种设计模式,标红是特别重要的设计者模式建议都会,而且熟读于心,标蓝是指其次重要建议也要明白。 (1)创建

    2024年01月24日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包