设计模式-迭代器

设计模式-迭代器

迭代器模式（Iterator Pattern）是一种广泛应用于软件工程中的行为设计模式，特别是在面向对象编程中。它的核心目标是提供一种统一的方法来顺序访问聚合对象（比如集合、列表或其他容器结构）中的元素，同时隐藏这些对象的内部细节和实现方式。

java已经封装好了迭代器，直接使用即可，foreach的本质就是用迭代器实现的。

直接上代码，有能力的兄弟可以直接看源代码。

/**
 * 聚集抽象类
 */
public interface Aggregate {
    /** 创建迭代器 */
    IteratorX createIterator();
}

/**
 * 迭代器抽象接口
 */
public interface IteratorX {
    /** 第一个 */
    Object first();
    /** 下一个 */
    Object next();
    /** 是否到最后 */
    boolean isDone();
    /** 当前对象 */
    Object currentItem();
}

/**
 * 具体聚集类
 * 用来存放数据
 */
public class ConcreteAggregate implements Aggregate{
    private List<Object> list = new ArrayList<>();

    @Override
    public IteratorX createIterator( ) {
        return new ConcreteIteratorX(this);
    }

    public int getCount(){
        return list.size();
    }

    public void add(Object o){
        list.add(o);
    }

    public Object getCurrentItem(int index){
        return list.get(index);
    }
}

/**
 * 具体实现迭代器
 */
public class ConcreteIteratorX implements IteratorX{
    private ConcreteAggregate aggregate;
    private int current = 0;

    public ConcreteIteratorX(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public Object first() {
        return aggregate.getCurrentItem(0);
    }

    @Override
    public Object next() {
        Object ret = null;
        current++;
        if (current < aggregate.getCount()){
            ret = aggregate.getCurrentItem(current);
        }
        return ret;
    }

    @Override
    public boolean isDone() {
        return current >= aggregate.getCount();
    }

    @Override
    public Object currentItem() {
        return aggregate.getCurrentItem(current);
    }
}

/**
 * 迭代器客户端
 */
public class iteratorDemo {
    public static void main(String[] args) {
        ConcreteAggregate concreteAggregate = new ConcreteAggregate();
        concreteAggregate.add("人A");
        concreteAggregate.add("人B");
        concreteAggregate.add("人C");
        concreteAggregate.add("人D");
        concreteAggregate.add("人E");

        ConcreteIteratorX concreteIteratorX = new ConcreteIteratorX(concreteAggregate);
        concreteIteratorX.first();
        while (!concreteIteratorX.isDone()){
            System.out.println("你是谁? 我是:" + concreteIteratorX.currentItem());
            concreteIteratorX.next();
        }
    }
}

打印结果:

Connected to the target VM, address: '127.0.0.1:18546', transport: 'socket'
你是谁? 我是:人A
你是谁? 我是:人B
你是谁? 我是:人C
你是谁? 我是:人D
你是谁? 我是:人E
Disconnected from the target VM, address: '127.0.0.1:18546', transport: 'socket'

以下是关于迭代器的核心概念和功能的简短总结：

1. 遍历元素： 迭代器允许用户按顺序访问集合中的每一个元素，但不需要了解集合的具体实现方式。通过next()方法逐个获取元素，直到没有更多元素为止。
2. 检查是否还有元素： 使用hasNext()方法来判断集合中是否还有尚未访问的元素，从而避免尝试访问不存在的下一个元素引发的错误。
3. 移除元素（可选）： 在某些迭代器实现中，提供了remove()方法，用于从当前迭代位置移除元素。并非所有迭代器都支持此操作，且通常只能在调用next()之后立即移除元素。
4. 不改变集合结构： 迭代器设计的一个重要原则是，在遍历过程中不能通过迭代器修改集合结构（添加或删除元素），以防止在遍历过程中出现并发修改异常。
5. 与集合解耦： 由于迭代器独立于具体的集合实现，因此可以在多种不同的数据结构上实现标准化的遍历逻辑，增强了代码的复用性和灵活性。
6. 多态性： 在支持迭代器接口的语言（如Java中的java.util.Iterator）中，任何实现了该接口的对象都可以被foreach循环或其他依赖迭代器机制的代码无缝地处理。

总结起来，迭代器作为一种设计模式，极大地简化了对集合元素的操作，提供了线性访问集合内元素的标准接口，使得算法可以更加通用和简洁。同时，它也保证了集合数据结构的封装性，有助于遵循面向对象编程的原则。