迭代器模式：按照顺序一次遍历集合中所有的元素

    优点：依序遍历元素，不会存在漏掉的情况

    实现：模拟一个公交车售票员售票的场景，不管车上乘客是什么人，坐车一律需要买票
    1、抽象迭代器、抽象集合类

    1. /**
    2.  * 迭代抽象类
    3.  */
    4. public abstract class Iterator {
    6.     /**
    7.      * 获取第一个对象
    8.      */
    9.     public abstract Object first();
    11.     /**
    12.      * 获取下一个对象
    13.      */
    14.     public abstract Object next();
    16.     /**
    17.      * 是否最后一个
    18.      */
    19.     public abstract Boolean idDone();
    21.     /**
    22.      * 获取当前对象
    23.      */
    24.     public abstract Object currentItem();
    25. }
    28. /**
    29.  * 集合抽象类
    30.  */
    31. public abstract class Aggregate {
    32.     /**
    33.      * 创建迭代器
    34.      */
    35.     public abstract Iterator createIterator();
    36. }

    2、具体迭代器、具体集合类

    1. /**
    2.  * 具体迭代器
    3.  */
    4. public class ConcreteIterator extends Iterator{
    6.     //集合类
    7.     private ConcreteAggregate aggregate;
    8.     private int current = 0;
    10.     public ConcreteIterator(ConcreteAggregate aggregate){
    11.         this.aggregate = aggregate;
    12.     }
    14.     /**
    15.      * 获取第一个对象
    16.      */
    17.     public Object first(){
    18.         return aggregate.getItem(0);
    19.     }
    21.     /**
    22.      * 获取下一个对象
    23.      */
    24.     public Object next(){
    25.         Object next = null;
    26.         current++;
    27.         if (current < aggregate.count()){
    28.             next = aggregate.getItem(current);
    29.         }
    30.         return next;
    31.     }
    33.     /**
    34.      * 是否最后一个
    35.      */
    36.     public Boolean idDone(){
    37.         return current < aggregate.count() ? false : true;
    38.     }
    40.     /**
    41.      * 获取当前对象
    42.      */
    43.     public Object currentItem(){
    44.         return aggregate.getItem(current);
    45.     }
    46. }
    48. /**
    49.  * 具体集合类
    50.  */
    51. public class ConcreteAggregate extends Aggregate{
    52.     private List<Object> item = new ArrayList<>();
    54.     public Iterator createIterator(){
    55.         return new ConcreteIterator(this);
    56.     }
    58.     public int count(){
    59.         return item.size();
    60.     }
    62.     public Object getItem(int number){
    63.         return item.get(number);
    64.     }
    66.     public void setItem(Object value){
    67.         item.add(value);
    68.     }
    69. }

    3、测试类

    1. /**
    2.  * 测试迭代器模式
    3.  */
    4. public class TestIterator {
    5.     public static void main(String [] args){
    6.         ConcreteAggregate concreteAggregate = new ConcreteAggregate();
    7.         concreteAggregate.setItem("乘客1");
    8.         concreteAggregate.setItem("乘客2");
    9.         concreteAggregate.setItem("乘客3");
    10.         concreteAggregate.setItem("公司员工");
    11.         concreteAggregate.setItem("小偷");
    13.         Iterator iterator = concreteAggregate.createIterator();
    14.         Object item = iterator.first();
    15.         System.out.println(MessageFormat.format("第一个乘客{0}", item));
    16.         while (!iterator.idDone()){
    17.             System.out.println(MessageFormat.format("{0}请买票" , iterator.currentItem()));
    18.             iterator.next();
    19.         }
    20.     }
    21. }

    测试结果：
    image.png

    迭代器模式就是我们最常用的foreach，现在已经封装的很成熟了，不需要自己去写，在此只是了解一下其原理