来聊一下Java中的迭代器（设计模式-迭代器模式）

背景

简而言之，集合的遍历如果用for来进行的话，需要知道集合的内部构造，想遍历数组的时候一样，需要索引有序。但是例如set集合是无序的使用for遍历不了。这时需要迭代器来遍历，把集合中所有的元素都找出来。

优势

使用迭代器可以在不了解集合内部数据结构的情况下直接遍历，这样可以使得集合内部的数据不暴露。
就如迭代器模式

什么是迭代器模式

迭代器模式又称为游标模式。它称为一种顺序访问集合/容器对象元素的方法，而又无须暴露集合内部表示。迭代器模式可以为不同的容器提供一致的遍历行为，而不用关心容器内容元素组成结构，属于行为型模式

迭代器模式的本质是抽离集合对象迭代行为到迭代器中，提供一致访问接口

迭代器模式的应用场景

迭代器模式在我们生活中应用的也比较广泛，比如物流系统中的传送带，不管传送的是什么物品，都被打包成一个一个的箱子并且有一个统一的二维码。这样我们不需要关心箱子里面是啥，我们在分发时只需要一个一个检查发送的目的地即可。再比如，我们平时乘坐交通工具，都是统一刷卡或者刷脸进站，而不需要关心是男性还是女性，是残疾人还是正常人等个性化的信息。

我们把多个对象聚在一起形成的总体称之为集合，集合对象是能够包容一组对象的容器对象。不同的集合其内部元素的聚合结构可能不同，而迭代器模式屏蔽了内部元素获取细节，为外部提供一致的元素访问行为，解耦了元素迭代与集合对象间的耦合，并且通过提供不同的迭代器，可以为同个集合对象提供不同顺序的元素访问行为，扩展了集合对象元素迭代功能，符合开闭原则

• 访问一个集合对象的内容而无须暴露它的内部表示
• 为遍历不同的集合结构提供一个统一的访问接口

涉及角色

1. 抽象迭代器（Iterator）: 抽象迭代器负责定义访问和遍历元素的接口
2. 具体迭代器（ConcreteIterator）: 提供具体的元素遍历行为
3. 抽象容器（IAggregate）: 负责定义提供具体迭代器的接口
4. 具体容器（ConcreteAggregate）：创建具体迭代器

自定义迭代器

我们以课程为例，创建一个课程的集合，集合中的每一个元素都是课程对象，然后自己手写一个迭代器，将每一个课程对象的信息读取出来

创建集合元素课程Course类

public class Course {
    private String name;

    public Course(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

创建自定义迭代器Iterator接口

public interface Iterator<E> {
    E next();

    Boolean hasNext();
}

创建自定义的课程集合CourseAggregate接口

public interface CourseAggregate {
    void add(Course course);

    void remove(Course course);

    Iterator<Course> iterator();
}

然后分别实现迭代器接口和集合接口

public class IteratorImpl<E> implements Iterator<E> {

    private List<E> list;
    private int cursor;
    private E element;

    public IteratorImpl(List<E> list) {
        this.list = list;
    }

    @Override
    public E next() {
        System.out.println("当前位置: " + cursor + ":");
        this.element = list.get(cursor);
        cursor++;
        return this.element;
    }

    @Override
    public Boolean hasNext() {
        if (cursor > list.size() - 1) {
            return false;
        }
        return true;
    }
}

public class CourseAggregateImpl implements CourseAggregate {

    private List courseList;

    public CourseAggregateImpl() {
        this.courseList = new ArrayList();
    }

    @Override
    public void add(Course course) {
        courseList.add(course);
    }

    @Override
    public void remove(Course course) {
        courseList.remove(course);
    }

    @Override
    public Iterator<Course> iterator() {
        return new IteratorImpl<>(courseList);
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Course java = new Course("Java架构");
        Course javaBean = new Course("Java基础");
        Course design = new Course("Java设计模式");
        Course ai = new Course("人工智能");

        CourseAggregate courseAggregate = new CourseAggregateImpl();
        courseAggregate.add(java);
        courseAggregate.add(javaBean);
        courseAggregate.add(design);
        courseAggregate.add(ai);

        System.out.println("-------课程列表-------");
        printCourses(courseAggregate);
    }

    private static void printCourses(CourseAggregate courseAggregate) {
        Iterator<Course> iterator = courseAggregate.iterator();
        while (iterator.hasNext()) {
            Course course = iterator.next();
            System.out.println("<< " + course.getName() + " >>");
        }
    }
}

运行结果

-------课程列表-------
当前位置: 0:
<< Java架构 >>
当前位置: 1:
<< Java基础 >>
当前位置: 2:
<< Java设计模式 >>
当前位置: 3:
<< 人工智能 >>