设计模式之迭代器模式(Iterator)

最新推荐文章于 2022-04-24 10:55:56 发布
最新推荐文章于 2022-04-24 10:55:56 发布
阅读量1.2w 收藏
点赞数
分类专栏： 设计模式 文章标签： 迭代模式 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_Java_Dog/article/details/117906991
版权

迭代器模式

迭代器模式

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示, 主要用于容器和容器遍历

数据结构中的物理结构只有两种:

第一种: 连续存储, 数组

第二种: 不连续存储, 链表 每个储存位置不但储存当前值, 还储存一个内存地址, 指向下个值的地址

数组演示

package com.cyc.design.iterator.v1;

/**
 * 构建一个容器，可以添加对象
 */

public class Main {
    public static void main(String[] args) {
        ArrayList_ list = new ArrayList_();
        for(int i=0; i<15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());
    }
}


/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class ArrayList_ {
    Object[] objects = new Object[10];
    //objects中下一个空的位置在哪儿,或者说，目前容器中有多少个元素
    private int index = 0;
    public void add(Object o) {
        if(index == objects.length) {
            //每次扩容两倍
            Object[] newObjects = new Object[objects.length*2];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }

        objects[index] = o;
        index ++;
    }

    public int size() {
        return index;
    }
}

链表演示

package com.cyc.design.iterator.v2;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 */

public class Main {
    public static void main(String[] args) {
        LinkedList_ list = new LinkedList_();
        for(int i=0; i<15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());
    }
}


/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class LinkedList_ {
    Node head = null;
    Node tail = null;
    //目前容器中有多少个元素
    private int size = 0;

    public void add(Object o) {
        Node n = new Node(o);
        n.next = null;

        if(head == null) {
            head = n;
            tail = n;
        }

        tail.next = n;
        tail = n;
        size++;
    }

    private class Node {
        //储存的值
        private Object o;
        //下一个节点的地址
        Node next;

        public Node(Object o) {
            this.o = o;
        }
    }

    public int size() {
        return size;
    }
}

相互替换

参照java的ArrayList和LinkedList让两者都实现自定义的Collection_接口

Collection_

package com.cyc.design.iterator.v3;

public interface Collection_ {
    void add(Object o);
    int size();
}

ArrayList_

package com.cyc.design.iterator.v3;


/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class ArrayList_ implements Collection_ {
    Object[] objects = new Object[10];
    //objects中下一个空的位置在哪儿,或者说，目前容器中有多少个元素
    private int index = 0;
    public void add(Object o) {
        if(index == objects.length) {
            Object[] newObjects = new Object[objects.length*2];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }

        objects[index] = o;
        index ++;
    }

    public int size() {
        return index;
    }
}

package com.cyc.design.iterator.v3;

/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class LinkedList_ implements Collection_ {
    Node head = null;
    Node tail = null;
    //目前容器中有多少个元素
    private int size = 0;

    public void add(Object o) {
        Node n = new Node(o);
        n.next = null;

        if(head == null) {
            head = n;
            tail = n;
        }

        tail.next = n;
        tail = n;
        size++;
    }

    private class Node {
        private Object o;
        Node next;

        public Node(Object o) {
            this.o = o;
        }
    }

    public int size() {
        return size;
    }
}

Main方法

package com.cyc.design.iterator.v3;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 * v3:添加容器的共同接口，实现容器的替换
 */

public class Main {
    public static void main(String[] args) {
        Collection_ list = new ArrayList_();
        for(int i=0; i<15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());
    }
}

容器遍历

package com.cyc.design.iterator.v4;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 * v3:添加容器的共同接口，实现容器的替换
 * v4:如何对容器遍历呢？
 */

public class Main {
    public static void main(String[] args) {
        Collection_ list = new ArrayList_();
        for(int i=0; i<15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());


        ArrayList_ al = (ArrayList_)list;
        for(int i=0; i<al.size(); i++) {
            //如果用这种遍历方式，就不能实现通用了
        }
    }
}

但是这种遍历方式不够灵活, 不是通用的,

解决方案: 让每种容器去实现自己的遍历方式

自己的遍历方式

  • Collection_
package com.cyc.design.iterator.v5;

public interface Collection_ {
    void add(Object o);

    int size();

    Iterator_ iterator();
}
  • Iterator_
package com.cyc.design.iterator.v5;

public interface Iterator_ {
    //判断是否有下一个值
    boolean hasNext();

    //下一个值
    Object next();
}
  • LinkedList_
package com.cyc.design.iterator.v5;

/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class LinkedList_ implements Collection_ {
    Node head = null;
    Node tail = null;
    //目前容器中有多少个元素
    private int size = 0;

    public void add(Object o) {
        Node n = new Node(o);
        n.next = null;

        if (head == null) {
            head = n;
            tail = n;
        }

        tail.next = n;
        tail = n;
        size++;
    }

    private class Node {
        private Object o;
        Node next;

        public Node(Object o) {
            this.o = o;
        }
    }

    public int size() {
        return size;
    }

    @Override
    public Iterator_ iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements Iterator_{

        private Node currentNode = head;

        @Override
        public boolean hasNext() {
            if (currentNode.next == null) {
                return false;
            }
            return true;
        }

        @Override
        public Object next() {
            Node node;
            if (currentNode == head) {
                node = head;
            } else {
                node = currentNode.next;
            }
            currentNode = currentNode.next;
            return node.o;
        }
    }
}
  • ArrayList_
package com.cyc.design.iterator.v5;


/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class ArrayList_ implements Collection_ {
    Object[] objects = new Object[10];
    //objects中下一个空的位置在哪儿,或者说，目前容器中有多少个元素
    private int index = 0;

    public void add(Object o) {
        if (index == objects.length) {
            Object[] newObjects = new Object[objects.length * 2];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }

        objects[index] = o;
        index++;
    }

    public int size() {
        return index;
    }

    @Override
    public Iterator_ iterator() {
        return new ArrayListIterator();
    }

    private class ArrayListIterator implements Iterator_ {

        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            if (currentIndex >= index) return false;
            return true;
        }

        @Override
        public Object next() {
            Object o = objects[currentIndex];
            currentIndex++;
            return o;
        }
    }


}

main方法

package com.cyc.design.iterator.v5;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 * v3:添加容器的共同接口，实现容器的替换
 * v4:如何对容器遍历呢？
 * v4:用一种统一的遍历方式，要求每一个容器都要提供Iterator的实现类
 * 作业：实现LinkedList的Iterator
 */

public class Main {
    public static void main(String[] args) {
        Collection_ list = new ArrayList_();
        for (int i = 0; i < 15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());

        //这个接口的调用方式：
        Iterator_ it = list.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }
    }
}

泛型版迭代

  • Collection_
package com.cyc.design.iterator.v7;

public interface Collection_<E> {
    void add(E o);
    int size();

    Iterator_ iterator();
}
  • Iterator_
package com.cyc.design.iterator.v7;

public interface Iterator_<E> { //Element //Type //K //Value V Tank
    boolean hasNext();

    E next(); //Tank next() Iterator_<Tank> it = ... Tank t = it.next();
}
  • ArrayList_
package com.cyc.design.iterator.v7;


/**
 * 相比数组，这个容器不用考虑边界问题，可以动态扩展
 */
class ArrayList_<E> implements Collection_<E> {
    E[] objects = (E[])new Object[10];
    //objects中下一个空的位置在哪儿,或者说，目前容器中有多少个元素
    private int index = 0;
    public void add(E o) {
        if(index == objects.length) {
            E[] newObjects = (E[])new Object[objects.length*2];
            System.arraycopy(objects, 0, newObjects, 0, objects.length);
            objects = newObjects;
        }

        objects[index] = o;
        index ++;
    }

    public int size() {
        return index;
    }

    @Override
    public Iterator_<E> iterator() {
        return new ArrayListIterator();
    }

    private class ArrayListIterator<E> implements Iterator_<E> {

        private int currentIndex = 0;

        @Override
        public boolean hasNext() {
            if(currentIndex >= index) return false;
            return true;
        }

        @Override
        public E next() {
            E o = (E)objects[currentIndex];
            currentIndex ++;
            return o;
        }
    }


}
  • Main
package com.cyc.design.iterator.v7;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 * v3:添加容器的共同接口，实现容器的替换
 * v4:如何对容器遍历呢？
 * v4:用一种统一的遍历方式，要求每一个容器都要提供Iterator的实现类
 *    作业：实现LinkedList的Iterator
 * v6:JDK的容器实现
 * v7:实现泛型版本
 */

public class Main {
    public static void main(String[] args) {
        Collection_<String> list = new ArrayList_<>();
        for(int i=0; i<15; i++) {
            list.add(new String("s" + i));
        }
        System.out.println(list.size());

        //这个接口的调用方式：
        Iterator_<String> it = list.iterator();
        while(it.hasNext()) {
            String o = it.next();
            System.out.println(o);
        }
    }
}

JDK的迭代器

在这里插入图片描述

package com.cyc.design.iterator.v6;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * v1:构建一个容器，可以添加对象
 * v2:用链表来实现一个容器
 * v3:添加容器的共同接口，实现容器的替换
 * v4:如何对容器遍历呢？
 * v4:用一种统一的遍历方式，要求每一个容器都要提供Iterator的实现类
 *    作业：实现LinkedList的Iterator
 * v6:JDK的容器的Iterator
 */

public class Main {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        for(int i=0; i<15; i++) {
            c.add(new String("s" + i));
        }

        Iterator it = c.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

点击ArrayList进入源码

在这里插入图片描述

在这里插入图片描述

意田天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
bert保存模型（输入不能分开IteratorV2）
qq_42738654的博客
12-24 816
今天下载google官方bert代码，发现使用estimator训练成ckpt格式，转成pb以后，发现输入融合到了一起。 使用pb推理的时候，用see.run出现错误。 inputs = graph.get_tensor_by_name(prex + "IteratorV2:0") # input_mask = graph.get_tensor_by_name(prex + "input_mask:0") # token_type_ids = graph.get_tensor_by_name(prex +
设计模式-Iterator模式（迭代器模式）
weixin_44030848的博客
07-17 423
对图解设计模式这本书中的iterator模式的小小理解。
迭代器模式（Iterator模式）
qq_35784669的博客
11-09 456
在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。 既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点： 暴露了聚合类的内部表示，使其数据不安全； 增加了客户的负担。 “迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类.
浅谈Iterator迭代器模式
学Java，找哪吒
09-19 4066
一、前言 设计模式有很多，最典型的是GoF的23种设计模式，听起来很多，其实大部分我们都是见过的，按照常见度来分，最常用的差不多是六七个吧，因此，我们在学习的时候应该有轻重缓急之分，不能一视同仁，而应该抓住重点，将一些最常用的设计模式吃透了，那么我们在遇到一个实际问题的时候就能根据问题的需要来进行相应的取舍。学习是一个循环往复的过程，没有学过一次不再接触就能掌握的，一定要反复的记忆，反复的练习...
设计模式——Iterator(迭代器)模式
qq_36566262的博客
04-20 241
目录前言1 定义2 适用性3 结构3.1 结构图3.2 参与者4 Java应用举例4.1 Iterator4.2 Collection4.3 AbstractList5 总结参考文献 前言 一个聚合对象，如容器列表，应该提供一种方法让别人可以访问自己的元素，而又不暴露自己的内部结果。同时可能有不同的需求，需要提供不同的遍历过程。 1 定义 Iterator(迭代器)模式：提供一种方法顺序访问一个聚合对象的各个元素，而又不暴露该对象的内部结构。 2 适用性 访问一个聚合对象的内部而不暴露内部结构。 支持对
PHP设计模式之迭代器模式Iterator实例分析【对象行为型】
10-15
迭代器模式是面向对象设计中的一种行为模式，它允许我们顺序访问聚合对象的元素，而无需暴露其底层结构。在PHP中，迭代器模式通过提供一个接口，使得客户端可以遍历任何类型的集合，如数组、关联数组或自定义的数据...
C++设计模式之迭代器模式（Iterator）
08-27
C++设计模式之迭代器模式（Iterator） 迭代器模式是一种常用的C++设计模式，主要用于访问容器中的元素，而不需要了解容器的内部结构。该模式提供了一种顺序访问容器中元素的方法，无需了解容器的内部类型和结构。 ...
PHP设计模式之迭代器模式
01-20
迭代器模式实例： <?php class ConcreteIterator implements Iterator{ private $position = 0; private $arr; function __construct(array $arr){ $this->arr = $arr; } function rewind(){ $
设计模式：迭代器模式（Iterator）
weixin_34388207的博客
04-04 215
提供一种方法顺序访问一个聚合对象中各个元素，而又不需暴露该对象的内部表示。又称游标（Cursor）模式。 迭代器模式角色组成： 1. 抽象容器角色（Aggregate）：负责提供创建具体迭代器角色的接口，一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。 2....
设计模式.迭代模式 Iterator
记录 分享 成就
04-24 118
速记 ArraylistIterator遍历方法 定义 迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。 场景 (1)访问一个聚合对象的内容而无需暴露它的内部表示 (2)支持对聚合对象的多种遍历 (3)为遍历不同的聚合结构提供一个统一的接口 类图 实现 （com.haiwei.behavior.iterator）  迭代器接口 public interface HaiweiIterator { boolea.
Java Iterator的设计模式
OranGO的专栏
06-11 707
今天看了“Thinking in java”Inner class章节，对Iterator的设计模式有了一点感悟，这里结合自己的拙见分享给感兴趣的各位。
设计模式之Iterator
xwdreamer的专栏
10-28 3828
1参考文章 参考1：http://topic.csdn.net/u/20080722/16/e7fcffc3-3d54-48f6-9d3a-2cd39073a287.html 参考2：http://www.java63.com/design_pattern/iterator_pattern.html 参考3：http://blog.csdn.net/aaaaaaaa0705/articl
设计模式之Iterator模式
风哲的博客
03-08 1497
在之前一篇文章《Java设计模式之六大设计原则》中说到了，设计模式是为了增强代码的可复用性，可拓展性，可维护性，灵活性。也说到几个设计模式的理论知识。这篇文章中主要讲一下Iterator设计模式，贯穿一种面向接口编程的思想，并且印证设计原则。        我们以一个书架的遍历为例子来讲解说明。现在，我希望定义一个简单的书架，这个书架上可以放书，还需要能遍历这个书架。我们先来看看传统的设计思想。
设计模式:迭代器（Iterator）模式
qwer0794的博客
07-13 3016
设计模式之迭代器（Iterator）模式 在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。 既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点： 暴露了聚合类的内部表示，使其数据不安全； 增加了客户的负担。 “迭代器模式”能较好地克
设计模式 行为型模式 实例 -- 迭代器模式实例：迭代数组
天行健 君子以自强不息，地势坤 君子以厚德载物。
11-23 972
1. 迭代器模式实例 1.1 需求分析 一个数组中存在Student和Teacher两种对象, 现有两种访问需求: 一个是访问所有学生,一个是访问所有人员, 请用迭代器模式实现两种访问,并打印出人员的基本信息. 1.2 类图分析 类图分析： 1.3 代码实现 1.3.1 People、Student、Teacher People: package ex08.iterator.role; /** * ClassName: People * Description: People类
Iterator （迭代器）的两种方式
qq_26514147的博客
07-15 780
第一种:　　Map map = new HashMap();　　Iterator iter = map.entrySet().iterator();　　while (iter.hasNext()) {　　Map.Entry entry = (Map.Entry) iter.next();　　Object key = entry.getKey();　　Object val = entry.getVa
设计模式-Iterator（迭代器）模式
zhanjunpeng01的博客
01-02 178
·设计模式篇均为读《图解设计模式》学习记录 迭代器模式，见名知意，遍历一个集合中的元素， 下面让我们看看我们常用的数组遍历 for(int i = 0; i &lt; arr.length; i++) { System.out.println(arr[i]); } 那么使用迭代器的遍历应该怎么做呢？ 先让我们看一下迭代器模式的类图： Aggregate 这个词是集合的意思...
【设计模式系列18】迭代器模式原理及其在JDK源码中的体现
zwx900102的博客
10-09 1537
迭代器模式原理模式原理及示例分析前言什么是迭代器模式迭代器模式示例迭代器模式角色迭代器模式在JDK源码中应用迭代器模式适用场景迭代器模式优缺点总结 前言 本文主要会介绍迭代器模式的原理，并会结合示例进行分析。迭代器模式其实我们基本上每个人都在用，可能只是自己没有察觉到这就是迭代器模式，等我们介绍完了大家就明白了，迭代器模式比较容易理解，而且一般应用开发使用的比较少，但是在底层的代码应用非常广泛 什么是迭代器模式 迭代器模式（Iterator Pattern）又称为游标者模式(Cursor Pattern)。
Java设计模式--迭代器模式（Iterator）
yanbin
03-29 356
概述 在软件开发中，我们经常需要使用聚合对象来存储一系列数据。聚合对象拥有两个职责：一是存储数据；二是遍历数据。从依赖性来看，前者是聚合对象的基本职责；而后者既是可变化的，又是可分离的。因此，可以将遍历数据的行为从聚合对象中分离出来，封装在一个被称之为“迭代器”的对象中，由迭代器来提供遍历聚合对象内部数据的行为，这将简化聚合对象的设计，更符合“单一职责原则”的要求。 定义：提供一种方法访问一个...
Java设计模式课件迭代器模式.pptx
最新发布
11-16
"Java设计模式课件迭代器模式.pptx" 迭代器模式是一种重要的设计模式，属于对象行为型模式，也被称为游标模式。它提供了一种方式，使得客户端可以顺序访问聚合对象（如集合）中的各个元素，而无需暴露这些对象的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

意田天

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值