定义:

  • 提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

    特点:

  • 访问一个聚合对象的内容而无须暴露它的内部表示。(优点)

  • 遍历任务交由迭代器完成,这简化了聚合类。(优点)
  • 增加新的聚合类和迭代器类都很方便,无须修改原有代码。(优点)
  • 封装性良好,为遍历不同的聚合结构提供一个统一的接口。(优点)
  • 增加了类的个数,这在一定程度上增加了系统的复杂性。(缺点)

    通常适用场景:

  • 当需要为聚合对象提供多种遍历方式时。
    -当需要为遍历不同的聚合结构提供一个统一的接口时。

  • 当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

    demo代码:

  • 迭代抽象类和具体子类 ```java //迭代器抽象类 public interface Iterator{ Object next(); boolean hasNext(); }

//具体迭代器 public class ConcreteIterator implements Iterator { private List list = null; private int index = -1;

  1. public ConcreteIterator(List<Object> list) {
  2. this.list = list;
  3. }
  4. public boolean hasNext() {
  5. return index < list.size() - 1;
  6. }
  7. public Object next() {
  8. Object obj = null;
  9. if (this.hasNext()) {
  10. obj = list.get(++index);
  11. }
  12. return obj;
  13. }

}


- 聚合抽象类和具体子类
```java
//聚合抽象类
public interface Aggregate{
    void add(Object obj);
    Iterator getIterator();

}
//具体聚合类
public class ConcreteAggregate implements Aggregate{

    private List<Object> list =new ArrayList<>();

    @Override
    public void add(Object obj) {
        list.add(obj);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
  }
  • 测试
    public static void main(String[] args) {
      Aggregate aggregate =new ConcreteAggregate();
      aggregate.add("1");
      aggregate.add("2");
      aggregate.add("3");
      Iterator iterator = aggregate.getIterator();
      while (iterator.hasNext()){
          System.out.println(iterator.next());
      }
    }