Android设计模式之——迭代器模式

一、介绍

迭代器模式（Iterator Pattern）又称为游标（Cursor）模式，是行为型设计模式之一。迭代器模式算是一个比较古老的设计模式，其源于对容器的访问，比如Java中的List、Map、数组等，我们知道对容器对象的访问必然会涉及遍历算法，我们可以将遍历的方法封装在容器中，或者不提供遍历方法。如果我们将遍历的方法封装到容器中，那么对于容器类来说就承担了过多的功能，容器类不仅要维护自身内部的数据元素而且还要对外提供遍历的接口方法，因为遍历状态的存储问题还不能对同一个容器同时进行多个遍历操作，如果我们不提供遍历方法而让使用者自己去实现，又会让容器的内部细节暴露无遗，正因于此，迭代模式应运而生，在客户访问类与容器体之间插入了一个第三者——迭代器，很好地解决了上面所述的弊端。

二、定义

提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示。

三、使用场景

  • 遍历一个容器对象。

四、迭代器模式的UML类图

UML类图：

这里写图片描述

通用模式代码：

迭代器接口：

public interface Iterator<T> {/*** 是否还有下一个元素* @return true表示有，false表示没有**/boolean hasNext();/*** 返回当前位置的元素并将位置移至下一位**/T next();
}

具体迭代器类：

public class ConcreteIterator<T> implements Iterator<T>{private List<T> list;private int cursor = 0;public ConcreteIterator(List<T> list) {this.list = list;}@Overridepublic boolean hasNext() {return cursor != list.size();}@Overridepublic T next() {T obj = null;if (this.hasNext()) {obj = this.list.get(cursor++);}return obj;}
}

容器接口：

public interface Aggregation<T> {/*** 添加一个元素**/void add(T obj);/*** 移除一个元素**/void remove(T obj);/*** 获取容器的迭代器**/Iterator<T> iterator();
}

具体容器类：

public class ConcreteAggregation<T> implements Aggregation<T>{private List<T> list = new ArrayList<>();@Overridepublic void add(T obj) {list.add(obj);}@Overridepublic void remove(T obj) {list.remove(obj);}@Overridepublic Iterator<T> iterator() {return new ConcreteIterator<>(list);}
}

客户类：

public class Client {public static void main(String args[]) {Aggregation<String> a = new ConcreteAggregation<>();a.add("a");a.add("b");a.add("c");Iterator<String> iterator = a.iterator();while (iterator.hasNext()) {System.out.print(iterator.next());}}
}

角色介绍：

  • Iterator：迭代器接口，迭代器接口负责定义、访问和遍历元素的接口。

  • ConcreteIterator：具体迭代器类，具体迭代器类的目的主要是实现迭代器接口，并记录遍历的当前位置。

  • Aggregate：容器接口，容器接口负责提供创建具体迭代器角色的接口。

  • ConcreteAggregate：具体容器类，具体迭代器角色与该容器相关联。

  • Client：客户类。

五、简单实现

小民和小辉分别在公司的两个事业部，某天老板安排任务让他们俩统计一下各自部门的员工数据，这很好办嘛，建一个类用数据结构把所有员工数据存进去即可，老板要看的时候给他用for循环实现，还是比较容易的，下面就先为员工创建一个实体类：

员工实体类：

public class Employee {private String name;// 姓名private int age;// 年龄private String sex;// 性别private String position;// 职位public Employee(String name, int age, String sex, String position) {super();this.name = name;this.age = age;this.sex = sex;this.position = position;}// 简化代码，省略setter和getter方法@Overridepublic String toString() {return "Employee{" + "name='" + name + '\'' + ", age=" + age + ", sex="+ sex + ", position='" + position + '\'' + "}";}
}

小民部门：

public class CompanyMin {private List<Employee> list = new ArrayList<>();public CompanyMin(){list.add(new Employee("小民", 26, "男", "程序猿"));list.add(new Employee("小芸", 22, "女", "测试"));list.add(new Employee("小方", 18, "女", "测试"));list.add(new Employee("可儿", 21, "女", "设计"));list.add(new Employee("朗情", 19, "女", "设计")); //吐槽一下，为什么就小民一个男的，小辉部门全男的。}public List<Employee> getEmployees(){return list;}
}

小辉部门：

public class CompanyHui {private Employee[] array = new Employee[3];public CompanyHui(){array[0] = new Employee("辉哥", 28, "男", "程序猿");array[1] = new Employee("小红", 23, "男", "程序猿");array[2] = new Employee("小辉", 25, "男", "程序猿");}public Employee[] getEmployees(){return array;}
}

可见小民和小辉的内部实现是两种方式，小民的人员信息容器的内部实质是使用的一个List类存储人员信息，而小辉的实质上使用的是一个数组，如果老板要查看人员信息就必须遍历两个容器：

Boss查看：

public class Boss {public static void main(String[] args) {CompanyHui hui = new CompanyHui();Employee[] huiList = hui.getEmployees();for(int i = 0; i < huiList.length; i++){System.out.println(huiList[i]);}CompanyMin min = new CompanyMin();List minList = min.getEmployees();for(int i = 0; i < minList.size(); i++){System.out.println(minList.get(i).toString());}}
}

结果：

Employee{name='辉哥', age=28, sex=男, position='程序猿'}
Employee{name='小红', age=23, sex=男, position='程序猿'}
Employee{name='小辉', age=25, sex=男, position='程序猿'}
Employee{name='小民', age=26, sex=男, position='程序猿'}
Employee{name='小芸', age=22, sex=女, position='测试'}
Employee{name='小方', age=18, sex=女, position='测试'}
Employee{name='可儿', age=21, sex=女, position='设计'}
Employee{name='朗情', age=19, sex=女, position='设计'}

这样看似也没有问题，但是如果有多个部门，每个部门有各自的实现，那么我们就要在Boss类中增加一遍遍历逻辑，这样Boss类的功能会越来越多，同时暴露了内部细节。那么我们需要定义一个迭代器接口：

public interface Iterator {/*** 是否还有下一个元素 * * @return true表示有，false表示没有*/boolean hasNext();/*** 返回当前元素，并将位置移至下一位*/Object next();
}

小民的迭代器：

public class MinIterator implements Iterator{private List<Employee> list;private int position;public MinIterator(List<Employee> list){this.list = list;}@Overridepublic boolean hasNext() {return !(position > list.size() - 1 || list.get(position) == null);}@Overridepublic Object next() {Employee e = list.get(position);position++;return e;}}

小辉的迭代器：

public class HuiIterator implements Iterator{private Employee[] array;private int position;public HuiIterator(Employee[] array){this.array = array;}@Overridepublic boolean hasNext() {return !(position > array.length - 1 || array[position] == null);}@Overridepublic Object next() {Employee e = array[position];position++;return e;}}

定义容器类的接口：

public interface Company {/*** 返回一个迭代器对象* * @return 迭代器对象*/Iterator iterator();}

修改一下之前的两个容器类：

public class CompanyHui implements Company{private Employee[] array = new Employee[3];public CompanyHui(){array[0] = new Employee("辉哥", 28, "男", "程序猿");array[1] = new Employee("小红", 23, "男", "程序猿");array[2] = new Employee("小辉", 25, "男", "程序猿");}public Employee[] getEmployees(){return array;}@Overridepublic Iterator iterator() {return new HuiIterator(array);}
}
public class CompanyMin implements Company{private List<Employee> list = new ArrayList<>();public CompanyMin(){list.add(new Employee("小民", 26, "男", "程序猿"));list.add(new Employee("小芸", 22, "女", "测试"));list.add(new Employee("小方", 18, "女", "测试"));list.add(new Employee("可儿", 21, "女", "设计"));list.add(new Employee("朗情", 19, "女", "设计"));}public List<Employee> getEmployees(){return list;}@Overridepublic Iterator iterator() {return new MinIterator(list);}
}

Boss查看：

public class Boss {public static void main(String[] args) {CompanyHui hui = new CompanyHui();check(hui.iterator());CompanyMin min = new CompanyMin();check(min.iterator());}private static void check(Iterator iterator){while (iterator.hasNext()) {System.out.println(iterator.next().toString());}}
}

六、Android源码中的迭代器模式

1、Cursor

当我们使用SQLiteDatabase的query方法查询数据库时，会返回一个Cursor游标对象，该游标的实质就是一个具体的迭代器，我们可以使用它来遍历数据库查询所得的结果集。

七、总结

迭代器模式发展至今，几乎所有的高级语言都有相应的内置实现，对于开发者而言，已经极少会自己去实现迭代器了，所以本章内容更多的是了解而非应用。

优点：

  • 符合面向对象设计原则中的单一职责原则。

  • 支持对容器对象的多种遍历。弱化了容器类与遍历算法之间的关系。

缺点：

  • 类文件的增加。

  • 会出现ConcurrentModificationException异常。

  • 遍历过程是一个单向且不可逆的遍历。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/447006.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Android设计模式之——模板方法模式

Android设计模式之——模板方法模式

一、介绍 在面向对象开发过程中&#xff0c;通常会遇到这样的一个问题&#xff0c;我们知道一个算法所需的关键步骤&#xff0c;并确定了这些步骤的执行顺序&#xff0c;但是&#xff0c;某些步骤的具体实现是未知的&#xff0c;或者说某些步骤的实现是会随着环境的变化而改变…
阅读更多...
Android设计模式之——访问者模式

Android设计模式之——访问者模式

一、介绍 访问者模式是一种将数据操作与数据结构分离的设计模式&#xff0c;它是《设计模式》中23种设计模式中最复杂的一个&#xff0c;但它的使用频率并不高&#xff0c;正如《设计模式》的作者GOF对访问者模式的描述&#xff1a;大多数情况下&#xff0c;你不需要使用访问者…
阅读更多...
Android设计模式之——中介者模式

Android设计模式之——中介者模式

一、介绍 中介者模式&#xff08;Mediator Pattern&#xff09;也称为调解者模式或调停者模式&#xff0c;Mediator本身就有调停者和调解者的意思。 在日常生活中调停者或调解者这个角色我们见得比较多的是“和事老”&#xff0c;也就是说调解两个有争端的人的角色&#xff0…
阅读更多...
Java基础——虚拟机结构

Java基础——虚拟机结构

一、Java平台结构图二、JVM、JRE和JDK关系JVM&#xff1a;Java Virtual Machine&#xff08;Java虚拟机&#xff09;&#xff0c;负责执行符合规范的Class文件 JRE&#xff1a; Java Runtime Environment &#xff08;java运行环境&#xff09;&#xff0c;包含JVM和类库 JDK&a…
阅读更多...
C++:MAC安装Boost库文件并且使用CLion开发

C++:MAC安装Boost库文件并且使用CLion开发

boost的filestem库 C在17版本的标准库中引入了一个filesystem库&#xff0c;用来处理文件路径&#xff0c;以及文件访问。很多编译器对filesystem库的支持还不是很好。为了解决这个问题&#xff0c;可以临时使用boost::filesystem来替代。其实C17标准中的filesystem库就是从bo…
阅读更多...
Java基础——Java异常处理机制

Java基础——Java异常处理机制

一、引言 try…catch…finally恐怕是大家再熟悉不过的语句了&#xff0c;而且感觉用起来也是很简单&#xff0c;逻辑上似乎也是很容易理解。不过&#xff0c;我亲自体验的“教训”告诉我&#xff0c;这个东西可不是想象中的那么简单、听话。不信&#xff1f;那你看看下面的代码…
阅读更多...
clion在使用sqlite3的时候，显示Undefined symbols for architecture x86_64错误的解决办法

clion在使用sqlite3的时候，显示Undefined symbols for architecture x86_64错误的解决办法

显示Undefined symbols for architecture x86_64错误的原因 1、缺少静态库 环境&#xff1a;在模拟器上报错但在真机上能运行成功&#xff0c;而且报的错误来自于第三方库。原因&#xff1a;architecture x86_64 是指模拟器的架构&#xff0c;意思就是 Crypto 变量在模拟器架…
阅读更多...
Java基础——类加载机制及原理

Java基础——类加载机制及原理

一、什么是类的加载&#xff1f; 类的加载指的是将类的.class文件中的二进制数据读入到内存中&#xff0c;将其放在运行时数据区的方法区内&#xff0c;然后在堆区创建一个java.lang.Class对象&#xff0c;用来封装类在方法区内的数据结构。类的加载的最终产品是位于堆区中的Cl…
阅读更多...
在Ubuntu环境下使用vcpkg安装sqlite_orm包文件

在Ubuntu环境下使用vcpkg安装sqlite_orm包文件

Ubuntu安装vcpkg 从github下载vcpkg的安装包&#xff0c;在usr/local路径下面执行如下命令 git clone https://github.com/Microsoft/vcpkg.git cd vcpkg //进入源码目录 ./bootstrap-vcpkg.sh //执行./bootstrap-vcpkg.sh进行编译安装&#xff0c;这个过程很慢 编译安装好…
阅读更多...
window电脑查看ssh公钥，以及将自己的公钥添加到Github等类似网站

window电脑查看ssh公钥，以及将自己的公钥添加到Github等类似网站

查看本机的ssh公钥 使用命令 cd ~/.ssh使用命令 ls 可以看到 id_rsa id_rsa.pub known_hosts 三个文件&#xff0c;此处需要的是id_rsa.pub文件使用命令 cat id_rsa.pub 查看文件的内容拷贝这段内容 添加自己的公钥 进入账户的设置页面参照如下步骤&#xff0c;进入SSH Key…
阅读更多...
java八大排序算法

java八大排序算法

一、概述 排序有内部排序和外部排序&#xff0c;内部排序是数据记录在内存中进行排序&#xff0c;而外部排序是因排序的数据很大&#xff0c;一次不能容纳全部的排序记录&#xff0c;在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大&#xff0c;则应采…
阅读更多...
windows安装 Git Large File Storage大文件下载工具ge

windows安装 Git Large File Storage大文件下载工具ge

下载地址 导航到 git-lfs.github.com 并单击Download开始下载git-lfs的用法指南 验证安装成功 打开Git Bash验证安装成功&#xff0c;使用命令 git lfs install &#xff0c;如果出现 >Git LFS initlized&#xff0c;就代表安装成功参考链接 安装 Git Large File Storag…
阅读更多...
Java基础——volatile关键字解析

Java基础——volatile关键字解析

简介volatile关键字虽然从字面上理解起来比较简单&#xff0c;但是要用好不是一件容易的事情。由于volatile关键字是与Java的内存模型有关的&#xff0c;因此在讲述volatile关键之前&#xff0c;我们先来了解一下与内存模型相关的概念和知识&#xff0c;然后分析了volatile关键…
阅读更多...
Java基础——Java IO详解

Java基础——Java IO详解

一、概述 1、Java IO Java IO即Java 输入输出系统。不管我们编写何种应用&#xff0c;都难免和各种输入输出相关的媒介打交道&#xff0c;其实和媒介进行IO的过程是十分复杂的&#xff0c;这要考虑的因素特别多&#xff0c;比如我们要考虑和哪种媒介进行IO&#xff08;文件、控…
阅读更多...
Java基础——Java NIO详解（二）

Java基础——Java NIO详解（二）

一、简介 在我的上一篇文章Java NIO详解&#xff08;一&#xff09;中介绍了关于标准输入输出NIO相关知识&#xff0c; 本篇将重点介绍基于网络编程NIO&#xff08;异步IO&#xff09;。 二、异步IO 异步 I/O 是一种没有阻塞地读写数据的方法。通常&#xff0c;在代码进行 rea…
阅读更多...
Java基础——Java NIO详解（一）

Java基础——Java NIO详解（一）

一、基本概念 1、I/0简介 I/O即输入输出&#xff0c;是计算机与外界世界的一个借口。IO操作的实际主题是操作系统。在java编程中&#xff0c;一般使用流的方式来处理IO&#xff0c;所有的IO都被视作是单个字节的移动&#xff0c;通过stream对象一次移动一个字节。流IO负责把对象…
阅读更多...
解决在sample文件夹里面写代码，在测试的时候因为virtual原因，make编译报错

解决在sample文件夹里面写代码，在测试的时候因为virtual原因，make编译报错

代码的结构 错误显示 解决办法 添加一句话&#xff0c;具体的cpp依据情况而定set_source_files_properties(${PROJECT_SOURCE_DIR}/src/sample_storage_test.cpp COMPILE_FLAGS "-Wno-unused-parameter")
阅读更多...
Android 多进程开发

Android 多进程开发

前言正常情况下&#xff0c;一个apk启动后只会运行在一个进程中&#xff0c;其进程名为AndroidManifest.xml文件中指定的应用包名&#xff0c;所有的基本组件都会在这个进程中运行。但是如果需要将某些组件&#xff08;如Service、Activity等&#xff09;运行在单独的进程中&am…
阅读更多...
clion中链接openssl库

clion中链接openssl库

错误显示 前提条件 apt-get install opensslapt-get install openssl-dev 解决办法 在CMakeLists.txt文件中加入如下命令link_libraries(crypto) 参考链接 无法将openssl库链接到CLion C 程序c - 无法将openssl库链接到CLion C程序
阅读更多...
Java提高篇 —— Java关键字之static的四种用法

Java提高篇 —— Java关键字之static的四种用法

一、前言 在java的关键字中&#xff0c;static和final是两个我们必须掌握的关键字。不同于其他关键字&#xff0c;他们都有多种用法&#xff0c;而且在一定环境下使用&#xff0c;可以提高程序的运行性能&#xff0c;优化程序的结构。下面我们先来了解一下static关键字及其用法…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023