大话设计模式学习笔记（20）——迭代器模式

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/q1052196521/article/details/79702507

源码git地址 https://github.com/dlovetco/designMode
其实迭代器模式说出来很简单，就是在java语言中的foreach遍历。只不过我们平时在用不会去深究foreach的内部算法，现在我们来自己手写一下遍历。

问题提出

体育老师让小明数一下有多少个同学来上体育课了。

package iteratorMode;

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

public class IteratorMode {
    public static void main(String[] args) {
        StudentAggregate studentAggregate = new StudentAggregate();//创建学生集合
        Iterator iterator = studentAggregate.createIterator();//创建迭代器
        studentAggregate.addStudent(new Student("小红"));
        studentAggregate.addStudent(new Student("小刚"));
        studentAggregate.addStudent(new Student("小明"));
        System.out.println(studentAggregate);
        System.out.println("迭代器开始遍历");
        System.out.println(iterator.first());
        while (iterator.hasNext()) {
            iterator.next();
            System.out.println(iterator.currentItem());
        }
    }
}

interface Iterator {
    Object next();

    Object first();

    boolean hasNext();

    Object currentItem();

}

class StudentIterator implements Iterator {
    private StudentAggregate studentAggregate;

    private int current = 0;

    public StudentIterator(StudentAggregate studentAggregate) {
        this.studentAggregate = studentAggregate;
    }

    @Override
    public Student next() {
        if (hasNext()) {
            return studentAggregate.getStudent(++current);
        }
        return null;
    }

    @Override
    public Student first() {
        if (studentAggregate != null && studentAggregate.size() > 0) {
            return studentAggregate.getStudent(0);
        }
        return null;
    }

    @Override
    public boolean hasNext() {
        return studentAggregate != null && studentAggregate.size() > 0 && studentAggregate.size() - current > 1;
    }

    @Override
    public Object currentItem() {
        return studentAggregate.getStudent(current);
    }
}

/**
 * 集合类的抽象接口
 */
interface Aggregate {
    Iterator createIterator();
}

/**
 * 表示学生的集合
 */
class StudentAggregate implements Aggregate {
    private List<Student> students = new ArrayList<>();

    public void addStudent(Student student) {
        students.add(student);
    }

    public Student getStudent(int index) {
        return students.get(index);
    }

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

    public int size() {
        return students.size();
    }

    @Override
    public String toString() {
        return "StudentAggregate{" +
                "students=" + students +
                '}';
    }
}

/**
 * 学生个体
 */
class Student {
    public Student(String name) {
        this.name = name;
    }

    private String name;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

输出：
StudentAggregate{students=[Student{name=’小红’}, Student{name=’小刚’}, Student{name=’小明’}]}
迭代器开始遍历
Student{name=’小红’}
Student{name=’小刚’}
Student{name=’小明’}

可以看到我们自己手写实现的迭代器成功的遍历了集合中所有对象。

plantuml

@startuml
interface Iterator{
{abstract}next();
{abstract}first();
{abstract}hasNext();
{abstract}currentItem();
}
Iterator <|.. StudentIterator
StudentIterator <.. StudentAggregate
class StudentIterator{
next();
first();
hasNext();
currentItem();
}

Iterator <-- Aggregate
interface Aggregate{
{abatract}Iterator createIterator()
}
Aggregate <|.. StudentAggregate
StudentAggregate <-- StudentIterator
class StudentAggregate{
List<Student> students
}
Student <..* StudentAggregate
class Student{
name
}
@enduml