十五、行为型（迭代器模式）

伯牙碎琴2024-10-17 10:20

迭代器模式（Iterator Pattern）

概念

迭代器模式是一种行为型设计模式，它用于提供一种顺序访问聚合对象（如集合、列表、数组）元素的方式，而无需暴露该对象的内部表示。迭代器模式将遍历行为从集合对象中分离出来，通过提供统一的接口来访问不同聚合对象中的元素。

应用场景

  1. 遍历集合对象：在系统中需要遍历不同类型的集合（如列表、栈、队列）时，迭代器模式可以提供一致的方式来遍历，而不必了解集合的内部结构。

  2. 封装集合的内部结构：迭代器隐藏了集合的具体实现细节，用户不需要关心集合的内部实现，例如数组的长度、链表的节点等，避免了直接操作集合对象。

  3. 解耦集合与算法：通过将遍历算法与集合本身分离，用户可以独立定义不同的迭代器，满足特定的遍历需求，如正序遍历、倒序遍历、跳步遍历等。

注意点

  • 并发修改问题：当集合在遍历过程中被修改（如新增或删除元素），可能会引发并发修改异常，需要特别注意在多线程场景下的使用。

  • 迭代器失效问题：一些容器在迭代时，如果容器内部结构改变（比如删除了一个元素），默认的迭代器会失效并抛出异常。

  • 内存管理：如果集合特别大且占用大量内存，使用迭代器遍历时应考虑如何管理内存，例如在遍历过程中是否需要保持所有元素在内存中。

核心要素

  1. Iterator（迭代器接口） ：定义访问和遍历元素的方法，例如next()和hasNext()。

  2. ConcreteIterator（具体迭代器）：具体的迭代器实现，实现迭代器接口并维护遍历状态。

  3. Aggregate（聚合对象接口）：定义创建迭代器的接口，用于返回具体的迭代器对象。

  4. ConcreteAggregate（具体聚合对象）：具体的集合类，实现创建迭代器的接口，并负责存储对象。

Java代码完整示例

代码示例：简单的迭代器模式实现

java 复制代码 
import java.util.ArrayList;
import java.util.List;

// 迭代器接口
interface Iterator<T> {
    boolean hasNext();
    T next();
}

// 聚合对象接口
interface Aggregate<T> {
    Iterator<T> createIterator();
}

// 具体迭代器实现
class ConcreteIterator<T> implements Iterator<T> {
    private List<T> items;
    private int position = 0;

    public ConcreteIterator(List<T> items) {
        this.items = items;
    }

    @Override
    public boolean hasNext() {
        return position < items.size();
    }

    @Override
    public T next() {
        return items.get(position++);
    }
}

// 具体聚合对象实现
class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(items);
    }
}

// 客户端代码
public class IteratorPatternDemo {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");

        Iterator<String> iterator = aggregate.createIterator();
        
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

输出结果：

Item 1
Item 2
Item 3

各种变形用法完整示例

  1. 倒序迭代器

    有时需要反向遍历集合，这时可以通过实现倒序迭代器来实现。

    代码示例：倒序迭代器

    java 复制代码 
    class ReverseIterator<T> implements Iterator<T> {
    private List<T> items;
    private int position;

    public ReverseIterator(List<T> items) {
        this.items = items;
        this.position = items.size() - 1;
    }

    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return items.get(position--);
    }
}

public class ReverseIteratorPatternDemo {
    public static void main(String[] args) {
        ConcreteAggregate<String> aggregate = new ConcreteAggregate<>();
        aggregate.addItem("Item 1");
        aggregate.addItem("Item 2");
        aggregate.addItem("Item 3");

        Iterator<String> reverseIterator = new ReverseIterator<>(aggregate.createIterator().items);
        
        while (reverseIterator.hasNext()) {
            System.out.println(reverseIterator.next());
        }
    }
}

    输出结果：

    Item 3
Item 2
Item 1

  2. 迭代器失效和并发修改异常

    当集合在迭代过程中发生变化时，通常会抛出ConcurrentModificationException异常，尤其在使用Java自带的集合类时需要特别注意。

    代码示例：并发修改异常

    java 复制代码 
    import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ConcurrentModificationDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Item 1");
        list.add("Item 2");
        list.add("Item 3");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            System.out.println(item);

            // 在迭代过程中修改集合，抛出异常
            if ("Item 2".equals(item)) {
                list.remove(item);
            }
        }
    }
}

    输出结果：

    Item 1
Item 2
Exception in thread "main" java.util.ConcurrentModificationException

  3. 自定义迭代器与泛型支持

    迭代器模式可以通过泛型来实现对不同类型的集合进行遍历。

    代码示例：自定义泛型迭代器

    java 复制代码 
    class GenericAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    @Override
    public Iterator<T> createIterator() {
        return new ConcreteIterator<>(items);
    }
}

public class GenericIteratorPatternDemo {
    public static void main(String[] args) {
        GenericAggregate<Integer> intAggregate = new GenericAggregate<>();
        intAggregate.addItem(1);
        intAggregate.addItem(2);
        intAggregate.addItem(3);

        Iterator<Integer> intIterator = intAggregate.createIterator();
        while (intIterator.hasNext()) {
            System.out.println(intIterator.next());
        }

        GenericAggregate<String> stringAggregate = new GenericAggregate<>();
        stringAggregate.addItem("Item A");
        stringAggregate.addItem("Item B");

        Iterator<String> stringIterator = stringAggregate.createIterator();
        while (stringIterator.hasNext()) {
            System.out.println(stringIterator.next());
        }
    }
}

    输出结果：

    1
2
3
Item A
Item B

  4. 内部类实现迭代器

    Java标准库中的集合类，如ArrayList等，通常通过内部类实现自己的迭代器。

    代码示例：内部类实现迭代器

    java 复制代码 
    class MyCollection<T> {
    private List<T> items = new ArrayList<>();

    public void addItem(T item) {
        items.add(item);
    }

    public Iterator<T> iterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<T> {
        private int index = 0;

        @Override
        public boolean hasNext() {
            return index < items.size();
        }

        @Override
        public T next() {
            return items.get(index++);
        }
    }
}

public class InnerClassIteratorDemo {
    public static void main(String[] args) {
        MyCollection<String> collection = new MyCollection<>();
        collection.addItem("Item X");
        collection.addItem("Item Y");

        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

    输出结果：

    Item X
Item Y

总结

迭代器模式通过提供统一的遍历接口，隐藏了聚合对象的内部结构，使得代码能够适应多种不同的集合类型。在实际开发中，Java标准库已经内置了大量的迭代器实现（如List、Set等），我们可以直接使用或扩展这些实现，来满足不同的需求。

相关推荐
Trouvaille ~3 天前
【C++篇】在秩序与混沌的交响乐中： STL之map容器的哲学探寻
开发语言·数据结构·c++·算法·迭代器模式·stl·map
XYX的Blog5 天前
设计模式08-行为型模式1(命令模式/迭代器模式/观察者模式/Java)
设计模式·迭代器模式·命令模式
丶白泽14 天前
重修设计模式-行为型-迭代器模式
java·设计模式·迭代器模式·1024程序员节
John_ToDebug24 天前
设计模式之迭代器模式
c++·设计模式·迭代器模式
刷帅耍帅1 个月前
设计模式-迭代器模式
设计模式·迭代器模式
湖南罗泽南1 个月前
设计模式之迭代器模式
设计模式·迭代器模式
java_heartLake1 个月前
设计模式之迭代器模式
java·设计模式·迭代器模式
仙魁XAN1 个月前
Unity 设计模式 之 行为型模式 -【中介者模式】【迭代器模式】【解释器模式】
设计模式·迭代器模式·解释器模式·中介者模式
coffee_baby1 个月前
深入探索迭代器模式的原理与应用
java·spring boot·迭代器模式·list
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解