个人学习笔记分享，当前能力有限，请勿贬低，菜鸟互学，大佬绕道
如有勘误，欢迎指出和讨论，本文后期也会进行修正和补充
前言
学习c/c++的时候，有两种常用的数据存储结构——链表&数组，两种结构都提供了自己的遍历方法。
总所周知，常规意义上的数组是连续的内存结构，即整个数组的内存空间在一起，查找的时候可以从首地址往后找目标就行；
而链表是非连续的，每个节点存储本节点数据和下一个节点的地址，内存空间不要求连续，查找的时候从首节点，不断查询下一个节点，直到找到目标；
然而在实际开发中，根据六大设计原则（单一职责原则”和“开闭原则”），我们不应该暴露给用户具体的内部数据和遍历方法，而是只需要提供查询当前节点数据，和查询下一个节点的方法即可，这也就是迭代器出现的原因。
比如Java的Collection中就包括了迭代器，使其能够忽略数据类型和集合类型进行遍历。
现实中也有此类例子，比如办理手续，我们会从最开始的营业厅开始，一环一环的找工作人员办理，但是我们没必要知道整个流程的每个环节，也没必要非环节间的关系，只管知道现在这个流程该做啥和下一个流程找谁就行。
1.介绍
适用目的：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
主要解决：不同的方式来遍历整个整合对象。
何时使用：遍历一个聚合对象。
如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。
关键代码：定义接口：hasNext, next。
应用实例：JAVA中的 iterator。
优点：
- 它支持以不同的方式遍历一个聚合对象。
- 迭代器简化了聚合类。
- 在同一个聚合上可以有多个遍历。
- 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
使用场景：
- 访问一个聚合对象的内容而无须暴露它的内部表示。
- 需要为聚合对象提供多种遍历方式。
- 为遍历不同的聚合结构提供一个统一的接口。
注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。
2.结构
主要包括以下角色：
- 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
- 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
- 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
- 具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。
3.实现步骤
-
定义抽象迭代器，定义数据遍历方法
//抽象迭代器 interface Iterator { Object first(); Object next(); boolean hasNext(); } -
定义迭代器，实现抽象迭代器
//具体迭代器 class ConcreteIterator implements Iterator { private List<Object> list = null; private int index = 0; public ConcreteIterator(List<Object> list) { this.list = list; } public boolean hasNext() { return list != null && index < list.size(); } public Object first() { return list != null && list.size() > 0 ? list.get(0) : null; } public Object next() { return this.hasNext() ? list.get(index++) : null; } }这里选用list来存储数据，对外部匿名，实际上根据需求选用其他结构也可以
-
定义抽象聚合角色，定义数据存储和查询方法，并定义获取迭代器方法
//抽象聚合 interface Aggregate { void add(Object obj); void remove(Object obj); Iterator iterator(); } -
定义具体聚合角色，实现抽象聚合角色
//具体聚合 class ConcreteAggregate implements Aggregate { private List<Object> list = new ArrayList<>(); public void add(Object obj) { list.add(obj); } public void remove(Object obj) { list.remove(obj); } public Iterator iterator() { return (new ConcreteIterator(list)); } }同理，这里使用了list，可以根据需求改变成需要的结构
测试方法
public class IteratorPattern {
public static void main(String[] args) {
Aggregate ag = new ConcreteAggregate();
ag.add("湖北");
ag.add("湖南");
ag.add("湖中间");
Iterator iterator = ag.iterator();
while (iterator.hasNext()) {
Object ob = iterator.next();
System.out.println(ob.toString());
}
ag.remove("湖南");
Iterator iterator2 = ag.iterator();
while (iterator2.hasNext()) {
Object ob = iterator2.next();
System.out.println(ob.toString());
}
}
}
运行结果
4.精简写法
上面的写法，其实很别扭的一点是在两个地方都定义了存储的结构，而且还得是一样的，反正我个人会抵触这种写法
在另一个地方看到的精简写法如下，但这样的耦合度更高
package com.company.designPattern.iteratorPattern2;
import java.util.ArrayList;
import java.util.List;
//抽象迭代器
interface Iterator {
Object first();
Object next();
boolean hasNext();
}
//抽象聚合
interface Aggregate {
void add(Object obj);
void remove(Object obj);
Iterator iterator();
}
//具体聚合
class ConcreteAggregate implements Aggregate {
private List<Object> list = new ArrayList<>();
public void add(Object obj) {
list.add(obj);
}
public void remove(Object obj) {
list.remove(obj);
}
public Iterator iterator() {
return new ConcreteIterator();
}
//具体迭代器
private class ConcreteIterator implements Iterator {
int index = 0;
public boolean hasNext() {
return index < list.size();
}
public Object first() {
return list.get(0);
}
public Object next() {
return this.hasNext() ? list.get(index++) : null;
}
}
}
public class IteratorPattern2 {
public static void main(String[] args) {
Aggregate ag = new ConcreteAggregate();
ag.add("湖北");
ag.add("湖南");
ag.add("湖中间");
Iterator iterator = ag.iterator();
while (iterator.hasNext()) {
Object ob = iterator.next();
System.out.println(ob.toString());
}
ag.remove("湖南");
Iterator iterator2 = ag.iterator();
while (iterator2.hasNext()) {
Object ob = iterator2.next();
System.out.println(ob.toString());
}
}
}
运行结果
5.扩展
与组合模式结合扩展
即使用迭代器替换掉组合模式中的存储和遍历方法
修改之前的组合模式demo，修改结果如下
package com.company.designPattern.iteratorPattern.test3;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
//抽象迭代器
interface Iterator {
Object first();
Object next();
boolean hasNext();
}
//抽象聚合
interface Aggregate {
void add(Object obj);
void remove(Object obj);
Iterator iterator();
}
@Data
class Employee implements Aggregate {
private String name;
private String dept;
private int salary;
// 加上static禁止被data注解提供直接访问方法
private static List<Employee> list = new ArrayList<>();
public Employee(String name, String dept, int salary) {
this.name = name;
this.dept = dept;
this.salary = salary;
}
public String toString() {
String subordinateNames = list.stream().map(Employee::getName).collect(Collectors.joining(", "));
return ("Employee :[ "
+ "Name : " + name
+ ", dept : " + dept
+ ", salary : " + salary
+ ", subordinate : " + subordinateNames
+ " ]");
}
public void showCurrent() {
System.out.println(this.toString());
}
public void showAll() {
showCurrent();
Iterator iterator = iterator();
while (iterator.hasNext()) {
((Employee) iterator.next()).showAll();
}
}
public void add(Object obj) {
list.add((Employee) obj);
}
public void remove(Object obj) {
list.remove(obj);
}
public Iterator iterator() {
return new ConcreteIterator();
}
//具体迭代器
private class ConcreteIterator implements Iterator {
int index = 0;
public boolean hasNext() {
return index < list.size();
}
public Object first() {
return list.get(0);
}
public Object next() {
return this.hasNext() ? list.get(index++) : null;
}
}
}
public class CompositeAndIteratorTest {
public static void main(String[] args) {
Employee clerk1 = new Employee("clerk1", "clerk", 10000);
Employee clerk2 = new Employee("clerk2", "clerk", 10000);
Employee manager = new Employee("manager1", "manager", 50000);
manager.add(clerk1);
manager.add(clerk2);
manager.showAll();
}
}
运行结果
后记
迭代器的作用即隐藏数据的内部存储结构，而通过迭代器接口的方式，提供统一的访问和修改方法
从而一方面提高了数据的安全性，因为外部将无法直接访问数据本身
另一方面也降低了用户学习成本，毕竟只需要看迭代器提供的接口就行，并不需要关注数据的结构
作者：Echo_Ye
WX：Echo_YeZ
Email ：echo_yezi@qq.com
个人站点：在搭了在搭了。。。（右键 - 新建文件夹）
