Android开发-设计模式-迭代器模式（Iterator）

最新推荐文章于 2024-09-07 11:16:03 发布
最新推荐文章于 2024-09-07 11:16:03 发布
阅读量478 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaocheng0404/article/details/107698593
版权

迭代器模式

介绍

        迭代器模式又叫游标模式（Cursor），是对象的行为模式。迭代器模式可以顺序地访问一个聚集中的元素而不必暴露聚集内部的表象。
        备注：Java聚集（Collection）对象是实现了共同的java.util.Collection接口的对象，是Java语言对聚集概念的直接支持。

模式引入

        在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。
        既然将遍历方法封装在聚合类中不可取，那么聚合类中不提供遍历方法，将遍历方法由用户自己实现是否可行呢？答案是同样不可取，因为这种方式会存在两个缺点：暴露了聚合类的内部表示，使其数据不安全，增加了使用者的负担。
        “迭代器模式”能较好地克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”。

        个人理解，在其他语言（如C语言），想要实现List、Set、Map这样的聚集需要自己编码去实现。这不仅要对语言要较深的理解，还要熟悉数据结构和迭代器模式才能写出性能良好、易维护、易扩展的聚集（List、Set、Map）；但对于Java程序员而言，Java有丰富的聚集（List、Set、Map），也为这些聚集提供了迭代器模式。因此大数情况下使用Java中已有的聚合类的迭代器就已经够了。（备注：熟悉迭代器模式有助于了解Java聚集的源码。）

模式角色

迭代器模式有以下角色：

  • Aggregate（抽象聚集），定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
  • ConcreteIterator（具体聚集），实现抽象聚合类，返回一个具体迭代器的实例。
  • Iterator（抽象迭代器），定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
  • ConcreteIterator（具体迭代器），实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

模式实现-白箱聚集与外迭代器

  • 白箱聚集：一个白箱聚集向外界提供访问自己内部元素的接口。
  • 外迭代器：具体迭代器在聚集外部声明（区别于内迭代器，内迭代器为聚集的内部类，Java聚集里是内迭代器）。
    外迭代器迭代逻辑由白箱聚集提供，所以这样的外迭代器仅仅保持迭代的游标位置。
    在这里插入图片描述
/**
* 抽象聚集
*/
public abstract class Aggregate {

    // 工厂方法，返回一个迭代器对象
    public Iterator createIterator() {
        return null;
    }
}

/**
* 具体聚集
*/
public class ConcreteAggregate extends Aggregate {

    private Object[] objs = {"City", "Smile", "Sun", "Happy"};

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }

    public Object getElement(int index) {
        if (index < objs.length) {
            return objs[index];
        } else {
            return null;
        }
    }

    public int size() {
        return objs.length;
    }
}

/**
* 抽象迭代器
*/
public interface Iterator {

    // 迭代器方法，移动到第一个元素
    void first();

    // 迭代器方法，移动到下一个元素
    void next();

    // 迭代器方法，是否是最后一个元素
    boolean isDone();

    // 迭代器方法，返回当前元素
    Object currentItem();
}

/**
* 具体迭代器
*/
class ConcreteIterator implements Iterator {

    private ConcreteAggregate agg;
    private int index = 0;
    private int size = 0;

    public ConcreteIterator(ConcreteAggregate agg) {
        this.agg = agg;
        size = agg.size();
        index = 0;
    }

    @Override
    public void first() {
        index = 0;
    }

    @Override
    public void next() {
        if (index < size) {
            index++;
        }
    }

    @Override
    public boolean isDone() {
        return (index >= size);
    }

    @Override
    public Object currentItem() {
        return agg.getElement(index);
    }
}

/**
* Client
*/
public class IteratorClient {

    private Iterator it;
    private Aggregate agg = new ConcreteAggregate();

    public void operation() {
        it = agg.createIterator();
        while (!it.isDone()) {
            System.out.println(it.currentItem());
            it.next();
        }
    }

    public static void main(String[] args) {
        IteratorClient client = new IteratorClient();
        client.operation();
    }
}

模式实现-黑箱聚集与内迭代器

  • 黑箱聚集：与白箱聚集相反，一个黑箱聚集不向外界提供访问自己内部元素的接口。因此，这些元素对象只可以被聚集内部成员访问。
  • 内迭代器：具体迭代器在聚集内部声明，也就是一个内迭代器是黑箱聚集类的内部类。
/**
* 抽象聚集
*/
abstract class Aggregate {

    // 工厂方法，返回一个迭代器对象
    public abstract Iterator createIterator();
}

/**
* 具体聚集
*/
class ConcreteAggregate extends Aggregate {

    private Object[] objs = {"City", "Smile", "Sun", "Happy"};

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator();
    }

    public Object getElement(int index) {
        if (index < objs.length) {
            return objs[index];
        } else {
            return null;
        }
    }

    public int size() {
        return objs.length;
    }
    
	/**
	* 内迭代器
	*/
    private class ConcreteIterator implements Iterator {

        private int index = 0;

        @Override
        public void first() {
            index = 0;
        }

        @Override
        public void next() {
            if (index < objs.length) {
                index++;
            }
        }

        @Override
        public boolean isDone() {
            return (index >= objs.length);
        }

        @Override
        public Object currentItem() {
            return objs[index];
        }
    }
}

/**
* 抽象迭代器
*/
public interface Iterator {

    // 迭代器方法，移动到第一个元素
    void first();

    // 迭代器方法，移动到下一个元素
    void next();

    // 迭代器方法，是否是最后一个元素
    boolean isDone();

    // 迭代器方法，返回当前元素
    Object currentItem();
}

/**
* Client
*/
class IteratorClient {

    private Iterator it;
    private Aggregate agg = new ConcreteAggregate();

    public void operation() {
        it = agg.createIterator();
        while (!it.isDone()) {
            System.out.println(it.currentItem());
            it.next();
        }
    }

    public static void main(String[] args) {
        IteratorClient client = new IteratorClient();
        client.operation();
    }
}

模式实现-静态迭代器

        静态迭代器由聚集对象创建，并持有聚集对象的一个快照（snapshot），在产生后这个快照的内容就不再变化。客户端可以继续修改原聚集里的内容，但是迭代器不会反映出聚集的变化。静态迭代器的优点是安全性和简易性；缺点是将原聚集复制了一份，导致对时间和内存资源的消耗，对大型聚集不合适。

/**
* 静态迭代器
*/
public class StaticIterator<E> {

    private final Vector<E> vector;
    private int count;

    public StaticIterator(Vector<E> vector) {
        // 将聚集对象复制一份。
        this.vector = (Vector<E>) vector.clone();
        count = 0;
    }

    /**
     * 迭代方法，移动到第一个元素
     */
    public void first(E e) {
        count = 0;
    }

    /**
     * 迭代方法，是否是最后一个元素
     */
    public boolean isDone() {
        return count < vector.size();
    }

    /**
     * 迭代方法，是否是最后一个元素
     */
    public E next() {
        synchronized (vector) {
            if (count < vector.size()) {
                return vector.get(count);
            }
        }
        throw new NoSuchElementException("DynamicIterator");
    }
}

模式实现-动态态迭代器

        动态迭代器与静态迭代器完全想法，在迭代器被产生之后，迭代器保持着对聚集对象的引用，因此，任何对原聚集内容的修改都会在迭代器对象上反映出来。完整的动态迭代器不容易实现，但是简化的动态迭代器并不难实现。大多数迭代器都是这种简化的动态迭代器，如前面的外迭代器。

/**
* 动态迭代器
*/
public class DynamicIterator<E> {

    private final Vector<E> vector;
    private int count;

    public DynamicIterator(Vector<E> vector) {
        this.vector = vector;
        count = 0;
    }

    /**
     * 迭代方法，移动到第一个元素
     */
    public void first() {
        count = 0;
    }

    /**
     * 迭代方法，是否是最后一个元素
     */
    public boolean isDone() {
        return count < vector.size();
    }

    /**
     * 迭代方法，是否是最后一个元素
     */
    public E next() {
        synchronized (vector) {
            if (count < vector.size()) {
                return vector.get(count);
            }
        }
        throw new NoSuchElementException("DynamicIterator");
    }
}

模式实现-主动迭代器和被动迭代器

        迭代器是主动的还是被动的，是相对于客户端而言的。如果客户端控制迭代的进程，那么这样的迭代器是主动迭代器；相反就是被动迭代器。
        使用主动迭代器的客户端会明显调用迭代器的next()等迭代方法；而使用被动迭代器的客户端并不明显地调用迭代方法，迭代器自行推进遍历过程。

模式不变对象

        一个白箱聚集对象可能是不变对象，前提是它的内部状态，包括聚集元素是不会改变的。
        一个黑箱聚集对象不可能是不变对象，因为它的内部状态是会改变的。
        关于“不变模式”可查看这篇文章。

Fail Fast机制

请查阅这篇文章。

CityCoder
关注
专栏目录
Android源码设计模式探索与实战【迭代器模式】
itbird的专栏
07-11 327
理解： 迭代器模式是行为型设计模式的一种。日常研发过程中，我们一般会说版本迭代，代表的是版本的顺序增长。还有一个字“器”，器一般是指工具，所以“迭代器”这个词从整体看，就是提供了一种迭代的工具。问题来了，工具是给谁来使用的，java中有集合的概念，例如：List、hashmap、vendor、array。看来，迭代器应该是给这些集合类提供的一种统一的、顺序访问其中元素的方法。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。之前我们说到过，如何区分一个模式，是结构型设计模式，还是行为型设计模
Android的设计模式-迭代器模式
四月葡萄的博客
11-25 459
前言Android的设计模式系列文章介绍，欢迎关注，持续更新中： Android的设计模式-设计模式的六大原则 创建型模式： Android的设计模式-单例模式 Android的设计模式-建造者模式 Android的设计模式-工厂方法模式 Android的设计模式-简单工厂模式 Android的设计模式-抽象工厂模式 Android的设计模式-原型模式
Android Iterator迭代器
zenmela2011的专栏
03-23 1171
1.Iterator Iterator迭代器是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。 Iterator为一个接口，它只提供了迭代了基本规则，在JDK中是这样定义的：对 collection 进行迭代的迭代器。迭代器取代了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同： ①迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。 ②方法名称得到了改进。 其
Android中的迭代器模式实践指南
最新发布
weixin_29009401的博客
09-07 1067
本文还有配套的精品资源，点击获取 简介：迭代器模式作为设计模式的一种，使我们能以统一的方式遍历集合而不暴露其内部结构。在Android开发中，该模式特别有用，尤其在管理和顺序访问复杂集合数据时。本示例将通过一个 MyApplication 应用来展示迭代器模式的实现和应用，包括聚合类、迭代器接口的定义和客户类的使用，以便于Android开发者理解并掌握其在实际...
设计模式——迭代器模式
java
12-04 286
迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。 介绍 意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。 主要解决：不同的方式来遍历整个整合对象。 何时使用：遍历一个聚合对象。 如何解决：把在元素之间游走的责任交给迭代器
android 迭代器模式,Android 架构师之路16 设计模式之迭代器模式
weixin_30666313的博客
06-02 176
1、迭代器模式概念1.1 介绍迭代器模式(Iterator Pattern)又称为游标(Cursor)模式，是行为型设计模式之一。源于对容器的访问，比如java中的list，Map，数组等，我们知道对容器对象的访问必然是多种多样的，所以我们把遍历的方法封装在容器中，或者不提供遍历方法。1.2 定义提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。1.3 使用场景访问一个...
Android编程设计模式之迭代器模式详解
01-04
本文实例讲述了Android编程设计模式之迭代器模式。分享给大家供大家参考，具体如下： 一、介绍 迭代器模式（Iterator Pattern）又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计...
Android设计模式之--迭代器模式
01-04
在Android设计模式中，迭代器模式的主要作用是分离了聚合对象（如数组、列表）与遍历它的方法。这样，我们可以在不改变聚合对象结构的情况下添加新的遍历方式，提高了代码的灵活性和可扩展性。迭代器模式通常包含...
设计模式在Android开发中的应用-迭代器模式
"Iterator(迭代器模式)是设计模式中的一种，在Android开发中扮演着重要角色。迭代器模式主要用于遍历容器对象中的元素，而无需暴露其底层表示。这种模式提供了一种统一的访问接口，使得代码更加简洁、可读性强。在...
Android Ap 开发 设计模式第一篇：迭代器模式
03-27
本文将深入探讨设计模式中的迭代器模式，这是一种在Android APK开发中非常实用的模式，特别是在处理集合数据时。 迭代器模式是一种行为设计模式，它的主要目的是提供一种方法来顺序访问聚合对象的元素，而又不暴露...
Android设计模式详解之迭代器模式
故不积跬步无以至千里
12-26 325
迭代器模式又称为游标模式，是行为型设计模式；提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示；遍历一个容器对象时；UML类图：迭代器接口，负责定义、访问和遍历元素的接口；具体迭代器类，实现迭代器接口，并记录遍历的当前位置；容器接口，负责提供创建具体迭代器角色；具体容器类；迭代器模式发展至今，几乎每一种高级语言都已经内置实现，极少需要自己去实现迭代器；支持以不同的方式去遍历一个容器对象，也可以有多个遍历，弱化了容器类与遍历算法之间的关系；类文件的增加；ღ( ´･ᴗ･` )
Android迭代器模式demo
04-13
Android迭代器模式demo,同步文章地址:http://blog.csdn.net/qq_28690547/article/details/51143529
安卓常见设计模式11------迭代器模式（Kotlin版）
jiet_h的博客
11-09 786
迭代器模式（Iterator Pattern）是一种行为设计模式，它提供了一种遍历集合对象的方法，而无需暴露集合的内部表示。迭代器模式由两个主要角色组成：迭代器（Iterator）和集合（Collection）。
java/android 设计模式学习笔记（20）---迭代器模式
Shawn_Dut的专栏
09-16 2308
我们这篇博客来介绍一下迭代器模式（Iterator Pattern），又称为游标（Cursor Pattern）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计模式，其源于对容器的访问，比如 Java 中的 List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对于容器类来说就承
Android设计模式源码解析之迭代器(Iterator)模式
古道边、半轮月
11-03 1117
1. 模式介绍 模式的定义 迭代器（Iterator）模式，又叫做游标（Cursor）模式。GOF给出的定义为：提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。 模式的使用场景 　　Java JDK 1.2 版开始支持迭代器。每一个迭代器提供next()以及hasNext()方法，同时也支持remove()(1.8的时候remov
Android 源码的迭代器模式
okclouderx的博客
11-12 167
Android 源码的迭代器模式 迭代器模式的介绍 迭代器模式（Iterator Pattern） 又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式是一个比较古老的设计模式，其源于对容器的访问，比如 Java 中的 List、Map、数组等。 迭代器模式的定义 提供一个方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。 Android 源码中的迭代器模式 And...
Android 迭代器 Iteraor迭代器以及foreach的使用
weixin_34104341的博客
04-11 154
Iterator是一个迭代器接口，专门用来迭代各种Collection集合，包括Set集合和List集合。 Java要求各种集合都提供一个iteratot()方法，该方法返回一个Iterator用于遍历集合中的元素。至于返回的Iterator是哪一种实现类我们并不关心，这就是典型的“迭代器模式”。 使用Iterator遍历集合元素，很好的隐藏了集合的内部细节。 Iterator接口包含以下三...
Android设计模式之迭代器模式
且听真言
12-18 288
迭代器模式又称游标模式， 是行为型设计模式之一。迭代器模式源于对容器的访问，比如Java中的List、Map、数组等。 对容器对象的访问必然会涉及到遍历算法，可以将遍历算法封装在容器中，或者不提供遍历算法。如果将遍历算法封装在容器中，那么容器类就承担了过多的功能，容器类不仅要维护自身内部的数据元素，而且还要对外提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个容器同时进行多个遍历操作，如果...
Android设计模式之——迭代器模式
Davis
10-30 7543
一、介绍迭代器模式（Iterator Pattern）又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计模式，其源于对容器的访问，比如Java中的List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对于容器类来说就承担了过多的功能，容器类不仅要维护自身内部
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值