迭代器模式

一、介绍

迭代器设计模式（Iterator Pattern），提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部实现，属于行为型模式，应该是java中应用最多的设计模式之一

迭代器，想到它是与集合相关的，集合也叫容器，可以将集合看成是一个可以包容对象的容器，例如List，Set，Map，甚至数组都可以叫做集合，迭代器的作用就是把容器中的对象一个一个地遍历出来

二、应用场景

一般来说，迭代器模式是与集合是共存的，只要实现一个集合，就需要同时提供这个集合的迭代器，就像java中的Collection，List、Set、Map等都有自己的迭代器

三、角色

抽象容器（Aggregate）：提供创建具体迭代器角色的接口，一般是接口，包括一个iterator()方法，例如java中的Collection接口，List接口，Set接口等。
具体容器角色（ConcreteAggregate）：实现抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkedList, Set接口的哈希列表的实现HashSet等。
抽象迭代器角色（Iterator）：负责定义访问和遍历元素的接口，包括几个核心方法，取得下一个元素的方法next()，判断是否遍历结束的方法isDone()（或者叫hasNext()），移除当前对象的方法remove()
具体迭代器角色（ConcreteIterator）：实现迭代器接口中定义的方法，并要记录遍历中的当前位置，完成集合的迭代

四、优缺点

优点
- 可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据
- 支持以不同的方式遍历一个聚合对象
缺点
- 对于比较简单的遍历（像数组或者有序列表），使用迭代器方式遍历较为繁琐
- 迭代器模式在遍历的同时更改迭代器所在的集合结构会导致出现异常

五、代码

具体代码比较复杂，只是使用list把思想写出来。

迭代器抽象接口

package com.lcy.study.design.iterator;

/**
 * @Description 迭代器抽象接口
 * @Author lcy
 * @Date 2021/7/27 16:26
 */
public interface Iterator {

    /**
     * 下一个对象
     * @return java.lang.Object
     * @author lcy
     * @date 2021/7/27 16:27
     **/
    Object next();

    /**
     * 是否拥有下一个对象
     * @return boolean
     * @author lcy
     * @date 2021/7/27 16:28
     **/
    boolean hasNext();

    /**
     * 删除对象
     * @param object 删除的对象
     * @return java.lang.Object
     * @author lcy
     * @date 2021/7/27 16:28
     **/
    Object remove(Object object);

}

具体迭代器

package com.lcy.study.design.iterator;

import java.util.List;

/**
 * @Description 具体迭代器
 * @Author lcy
 * @Date 2021/7/27 16:29
 */
public class ConcreteIterator implements Iterator {

    /**
     * 集合
     */
    private final List<Object> list;

    /**
     * 下标
     */
    private int index = 0;

    public ConcreteIterator(List<Object> list){
        this.list = list;
    }

    @Override public Object next(){
        Object object = null;
        if (hasNext()) {
            object = list.get(index);
            index++;
        }
        return object;
    }

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

    @Override public Object remove(Object object){
        return list.remove(object);
    }
}

抽象容器

package com.lcy.study.design.iterator;

/**
 * @Description 抽象容器
 * @Author lcy
 * @Date 2021/7/27 16:35
 */
public interface Collection {

    /**
     * 添加对象
     * @param object 对象
     * @author lcy
     * @date 2021/7/27 16:36
     **/
    void add(Object object);

    /**
     * 删除对象
     * @param object 对象
     * @author lcy
     * @date 2021/7/27 16:36
     **/
    void remove(Object object);

    /**
     * 返回迭代器
     * @return com.lcy.study.design.iterator.Iterator
     * @author lcy
     * @date 2021/7/27 16:37
     **/
    Iterator iterator();

}

具体容器

package com.lcy.study.design.iterator;

import java.util.List;

import lombok.AllArgsConstructor;

/**
 * @Description 具体容器
 * @Author lcy
 * @Date 2021/7/27 16:29
 */
@AllArgsConstructor
public class ConcreteCollection implements Collection {

    /**
     * list
     */
    private final List<Object> list;

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

    @Override public void remove(Object object){
        list.remove(object);
    }

    @Override public Iterator iterator(){
        return new ConcreteIterator(list);
    }
}

迭代器调用

package com.lcy.study.design.iterator;

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

/**
 * @Description 迭代器模式调用
 * @Author lcy
 * @Date 2021/7/27 16:39
 */
public class IteratorMain {

    public static void main(String[] args){
        List<Object> list = new ArrayList<>();
        list.add("1");
        list.add("2");
        list.add("3");
        Collection collection = new ConcreteCollection(list);
        Iterator iterator = collection.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

迭代器模式 ​

一、介绍 ​

二、应用场景 ​

三、角色 ​