设计模式之迭代器模式

最新推荐文章于 2024-08-29 17:15:49 发布
最新推荐文章于 2024-08-29 17:15:49 发布
阅读量516 收藏 14
点赞数 14
分类专栏： 设计模式 文章标签： 设计模式 迭代器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smart_an/article/details/136036647
版权

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

阶段2、深入多线程设计模式

阶段3、深入juc源码解析


阶段4、深入jdk其余源码解析


阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

​​​​​​码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

迭代器模式

定义

迭代器模式Iterator Design Pattern也叫游标模式Cursor Design Pattern。用来遍历集合对象(如数组、链表、树、图、跳表)。

迭代器模式将集合对象的遍历操作从集合类中拆分出来，让两者的职责更加单一。

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部的表示。

类图

实现

1. 定义迭代器接口

    public interface MyIterator<E> {
        /**
         * 判断是否有下一个元素
         * @return
         */
        boolean hasNext();
    
        /**
         * 迭代器内部指针+1动作
         */
        void next();
    
        /**
         * 返回当前元素
         * @return
         */
        E currentItem();
    }

2. 定义相对应容器迭代器实现

    public class ArrayIterator<E> implements MyIterator {
        private int cursor;
        private ArrayList<E> arrayList;
    
        public ArrayIterator(ArrayList<E> arrayList) {
            this.cursor = 0;
            this.arrayList = arrayList;
        }
    
        @Override
        public boolean hasNext() {
            return cursor != arrayList.size();
        }
    
        @Override
        public void next() {
            cursor++;
        }
    
        @Override
        public Object currentItem() {
            return  arrayList.get(cursor);
        }
    }

3. 使用迭代器

    public class T {
        public static void main(String[] args) {
            ArrayList<String> name = new ArrayList<>();
            name.add("jjj");
            name.add("zwf");
            name.add("xxx");
    
            MyIterator<String> iterator = new ArrayIterator<>(name);
            while (iterator.hasNext()) {
                System.out.println(iterator.currentItem());
                iterator.next();
            }
        }
    }

JAVA迭代器实现

1. 迭代器定义

    public interface Iterator<E> {
        /**
         * Returns {@code true} if the iteration has more elements.
         * (In other words, returns {@code true} if {@link #next} would
         * return an element rather than throwing an exception.)
         *
         * @return {@code true} if the iteration has more elements
         */
        boolean hasNext();
    
        /**
         * Returns the next element in the iteration.
         *
         * @return the next element in the iteration
         * @throws NoSuchElementException if the iteration has no more elements
         */
        E next();
    
        default void remove() {
            throw new UnsupportedOperationException("remove");
        }
    
        default void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            while (hasNext())
                action.accept(next());
        }
    }

2. ArrayList迭代器实现

    private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        // modCount这是ArrayList中定义的一个成员变量: 记录集合被修改的次数。集合每调用一次增加或删除元素的函数，就会把modcount++
        // 当我们通过iterator()创建迭代器进行迭代元素时，会把modCount传给expectedModCount。之后每次调用 hasNext()、next()、currentItem()函数时
        // 都会检查modCount是否变更过。如果存在变量，则表明集合被其他人修改过，抛出ConcurrentModificationException()异常。fail-fast解决方式。
        int expectedModCount = modCount;
    
        // prevent creating a synthetic constructor
        Itr() {}
    
        public boolean hasNext() {
            return cursor != size;
        }
    
        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }
    
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
    
            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                // lastRet:记录游标指向的前一个元素。
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }
    
        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            final int size = ArrayList.this.size;
            int i = cursor;
            if (i < size) {
                final Object[] es = elementData;
                if (i >= es.length)
                    throw new ConcurrentModificationException();
                for (; i < size && modCount == expectedModCount; i++)
                    action.accept(elementAt(es, i));
                // update once at end to reduce heap write traffic
                cursor = i;
                lastRet = i - 1;
                checkForComodification();
            }
        }
    
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

3. ArraysList类组合迭代器

     public Iterator<E> iterator() {
    	return new Itr();
     }

4. ArrayList小结

关于迭代删除操作

Java迭代器中的remove()方法还是比较鸡肋的，作用有限。它只能删除游标指向的前一个元素，而且一个next()函数之后，只能跟着最多一个remove()操作。多次调用removce()操作会报错。

支持快照功能的迭代器

    public class MyArraysList<E> implements List<E> {
        // 初始化容量大小
        private static final int DEFAULT_CAPACITY = 10;
        // 使用数组存储元素
        private Object[] elementData;
        // 存放元素添加时间戳
        private long[] addTimeStamp;
        // 存放元素删除时间戳
        private long[] deleteTimeStamp;
        // 集合总大小(包含被删除元素、元素并未进行删除，只是删除动作修改了deleteTimeStamp时间戳)
        private int totalSize;
        // 集合实际大小
        private int actualSize;
    
        public MyArraysList() {
            this.elementData = new Object[DEFAULT_CAPACITY];
            this.addTimeStamp = new long[DEFAULT_CAPACITY];
            this.deleteTimeStamp = new long[DEFAULT_CAPACITY];
            this.totalSize = 0;
            this.actualSize = 0;
        }
    
        public MyArraysList(int size) {
            this.elementData = new Object[size];
            this.addTimeStamp = new long[size];
            this.deleteTimeStamp = new long[size];
            this.totalSize = 0;
            this.actualSize = 0;
        }
    
        @Override
        public boolean add(E e) {
            elementData[totalSize] = e;
            addTimeStamp[totalSize] = System.currentTimeMillis();
            deleteTimeStamp[totalSize] = Long.MAX_VALUE;
            actualSize++;
            totalSize++;
            return true;
        }
    
        /**
         * 元素删除动作
         * 1.将deleteTimeStamp相应的数组序号置为当前时间
         * 2.实际元素统计值actualSize减一
         * @param o
         * @return
         */
        @Override
        public boolean remove(Object o) {
            for (int i = 0; i < totalSize; i++) {
                if (elementData[i].equals(o)) {
                    deleteTimeStamp[i] = System.currentTimeMillis();
                    actualSize--;
                }
            }
            return true;
        }
    
        /**
         * 创建一个新的迭代器
         * @return
         */
        @Override
        public Iterator<E> iterator() {
            return new SnapshotArrayIteraotr(System.currentTimeMillis());
        }
    
        private class SnapshotArrayIteraotr<E> implements Iterator<E> {
            // 创建迭代器时间戳
            private long snapshotTimestap;
            // 当前游标位置
            private int cursor;
    
            public SnapshotArrayIteraotr(long snapshotTimestap) {
                this.snapshotTimestap = snapshotTimestap;
                this.cursor = 0;
            }
    
            /**
             * 是否还有下一个元素
             * @return
             */
            @Override
            public boolean hasNext() {
                return cursor <= totalSize;
            }
    
            /**
             * 有两个步骤
             * 1.获取cursor游标的值
             * 2.找寻下一个游标位置
             * @return
             */
            @Override
            public E next() {
                E result =(E) elementData[cursor];
                jumpToNextCursor();
                return result;
            }
    
            /**
             * 找寻下一个可用的游标
             */
            private void jumpToNextCursor() {
                while (cursor++ < totalSize) {
                    long addTime = addTimeStamp[cursor];
                    long deleteTime = deleteTimeStamp[cursor];
                    if (snapshotTimestap >= addTime && snapshotTimestap < deleteTime) {
                        // 在这个时间范围内的
                        break;
                    }
                }
            }
        }
    }
  • 类似于数据库的MVVC。
  • 容器中维护两个多出来的数组。分别是添加时间、删除时间。当元素添加时间时间 <= 迭代器创建时间 <元素删除时间(初始默认值为Long.MAX_VALUE)时，表明该元素属于此版本，可以输出。

总结

  1. 迭代器封装集合内部数据结构，开发者不需要了解如何遍历，直接使用容器提供的迭代器即可。
  2. 迭代器模式将集合对象的遍历操作从集合类中拆分出来，使得两者职责更加单一。
  3. 迭代器模式让添加新的遍历算法更加容易，更符合开闭原则。
smart哥
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式之迭代器模式
K1_uestc的博客
01-23 1368
迭代器模式是⼀种行为设计模式，是⼀种使⽤频率⾮常⾼的设计模式，在各个语⾔中都有应用，其主要⽬的是提供⼀种统⼀的⽅式来访问⼀个聚合对象中的各个元素，而不需要暴露该对象的内部表示。通过迭代器，客户端可以顺序访问聚合对象的元素，而无需了解底层数据结构。
设计模式之迭代器模式(C++)
热门推荐
翟天保的博客
04-12 1万+
介绍设计模式之迭代器模式
C++设计模式之迭代器模式（Iterator）
08-27
C++设计模式之迭代器模式（Iterator） 迭代器模式是一种常用的C++设计模式，主要用于访问容器中的元素，而不需要了解容器的内部结构。该模式提供了一种顺序访问容器中元素的方法，无需了解容器的内部类型和结构。 ...
Android编程设计模式之迭代器模式详解
01-04
迭代器模式算是一个比较古老的设计模式，其源于对容器的访问，比如Java中的List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将...
行为型设计模式-模板方法（template method）模式
linkedin_21843693的博客
08-26 460
模板方法模式通过在一个方法中定义算法的骨架，将算法的某些步骤的实现推迟到子类中，从而允许子类在不改变算法结构的情况下，重新定义算法中的某些步骤。这种模式特别适用于那些具有多个步骤，其中一些步骤经常变化而另一些保持不变的情况。
设计模式&设计原则
docuxu的博客
08-27 1525
（最少知道原则）
设计模式结构型模式之适配器模式
最新发布
针线犹存未忍开
08-29 902
适配器模式是一种结构型设计模式，它允许不兼容的接口之间进行适配，使得原本无法一起工作的类可以协同工作。适配器模式通过引入一个适配器类，将一个类的接口转换成客户端所期待的接口，从而使原本由于接口不兼容而不能一起工作的两个类能够协同工作。适配器模式（Adapter Pattern）是一种结构型设计模式，它允许现有的类与其他类或接口进行协作，解决了类之间接口不兼容的问题。
行为型设计模式-访问者（visitor）模式
linkedin_21843693的博客
08-26 511
访问者模式通过将操作逻辑封装在访问者对象中，允许对对象结构中的元素执行操作而无需修改这些元素类。这使得添加新的操作变得简单，同时也保持了元素类的稳定性。适用于那些需要对对象结构。
设计模式（一）：七大原则
qq_34721505的博客
08-26 604
其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好。在一个软件产品中，父类对象可以出现的地方，都可以替换成它的子类对象，且不能发生错误和异常，里氏替换原则为良好的继承定义了规范。设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据。
设计模式 8 组合模式
小小程序猿
08-27 864
组合模式通过定义树形结构来组成对象，使得客户端对单个对象和对象集合的处理方式一致。这个模式让你可以使用相同的接口来操作单一对象和对象集合，简化了代码和操作逻辑。
前端宝典十六：深入浅出8大设计模式
franktaoge的博客
08-24 1525
本文主要探讨前端开发中的各种设计模式，主要分类有： - 单例模式 - 建造者模式 - 代理模式 - 装饰器模式 - 适配器模式 - 策略模式 - 观察者模式 - 发布订阅模式 通过对他们实际开发中的使用场景的解析，深入浅出的一起更全面直观的进行学习：
Day15_设计模式
weixin_45014721的博客
08-25 1145
整个系统只能使用一个对象实例。（1）饿汉式单例模式的写法：线程安全（2）懒汉式单例模式的写法：非线程安全（3）双检锁单例模式的写法：线程安全类是public修饰的，而且类里面只有一个public，其余的都是private。如果一个对象不能处理该请求， 那么它会把相同的请求传给下一个，它们连成一条链，并沿着这条链传递该请求请求处理者（节点对象）只需关注自己感兴趣的请求进行处理即可，对于不感兴趣的请求，直接转发给下一级节点对象；链路结构灵活，可以通过改变链路结构动态地新增或删减责任；
设计模式--策略模式
m0_62965917的博客
08-27 840
策略模式（Strategy Pattern）是一种行为型设计模式，用于定义一系列算法，并将每一个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 2284
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Java设计模式：迭代器模式详解
"Java设计模式课件迭代器模式.pptx" 迭代器模式是一种重要的设计模式，属于对象行为型模式，也被称为游标模式。它提供了一种方式，使得客户端可以顺序访问聚合对象（如集合）中的各个元素，而无需暴露这些对象的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值