16-迭代器模式

16-迭代器模式

概念

迭代器模式（Iterator）:提供一种方法顺序访问一个聚合对象中各元素，而又不暴露该对象的内部表示

什么时候使用？
当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑使用迭代器模式
你需要对聚集有多重方式遍历时，可以考虑用迭代器模式
为遍历不同的聚集结构提供如开始、下一个、是否结束，当前哪一项等统一的接口

实现

package com.gof.iterator;

/**
 * 迭代器
 *
 * @since 2023-02-17
 */
public interface Iterator<T> {
    public T first();

    public T next();

    public boolean isDone();

    public T currentItem();

}

package com.gof.iterator;

/**
 * 功能描述
 *
 * @since 2023-02-17
 */
public class ConcreteIterator<T> implements Iterator<T> {
    private ConcreteAggregate<T> aggregate;

    private int current = 0;

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

    @Override
    public T first() {
        return aggregate.getItems(0);
    }

    @Override
    public T next() {
        current++;
        if (current < aggregate.count()) {
            return aggregate.getItems(current);
        }
        return null;

    }

    @Override
    public boolean isDone() {

        return current >= aggregate.count();
    }

    @Override
    public T currentItem() {
        return aggregate.getItems(current);
    }
}

package com.gof.iterator;

/**
 * 功能描述
 *
 * @since 2023-02-17
 */
public interface Aggregate<T> {
    public Iterator createIterator();
}

package com.gof.iterator;

import java.util.ArrayList;
import java.util.List;

/**
 * 功能描述
 *
 * @since 2023-02-17
 */
public class ConcreteAggregate<T> implements Aggregate<T> {
    private List<T> items = new ArrayList<>();

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

    public int count() {
        return items.size();
    }

    public T getItems(int index) {
        return items.get(index);
    }

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

package com.gof.iterator;

/**
 * 功能描述
 *
 * @since 2023-02-22
 */
public class Client {
    public static void main(String[] args) {
        ConcreteAggregate<String> bus = new ConcreteAggregate<>();
        bus.setItems("大鸟");
        bus.setItems("小菜");
        bus.setItems("行李");
        bus.setItems("老外");
        bus.setItems("公交内部员工");
        bus.setItems("小偷");

        ConcreteIterator<String> iterator = new ConcreteIterator<>(bus);
        while (!iterator.isDone()) {
            System.out.println(iterator.currentItem() + "请买票");
            iterator.next();
        }
    }
}

总结

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据