GOF23设计模式之迭代器模式（iterator）

淡淡的烟草味﹌ 2023-10-06 09:47 2阅读 0赞

#### 一、迭代器模式概述 ####

提供一种可以遍历聚合对象的方式。又称为：游标（cursor）模式

结构：

（1）聚合对象：存储数据

（2）迭代器：遍历数据

#### 二、迭代器模式示例代码 ####

定义：正向遍历迭代器和逆向遍历迭代器

1 /**
     2  * 自定义迭代器接口
     3  * @author CL
     4  *
     5  */
     6 public interface MyIterator {
     7     /**
     8      * 如果仍有元素可以迭代，则返回 true
     9      * @return
    10      */
    11     boolean hasNext();
    12     /**
    13      * 返回迭代的下一个元素
    14      * @return
    15      */
    16     Object next();
    17     /**
    18      * 从迭代器指向的集合中移除迭代器返回的最后一个元素
    19      */
    20     void remove();
    21     
    22 }

1 import java.util.ArrayList;
     2 import java.util.List;
     3 
     4 /**
     5  * 自定义聚合类
     6  * @author CL
     7  *
     8  */
     9 public class ConcreteAggregate {
    10     private List<Object> list;
    11 
    12     public ConcreteAggregate() {
    13         list = new ArrayList<Object>();
    14     }
    15     
    16     public boolean addObject(Object obj) {
    17         return this.list.add(obj);
    18     }
    19     
    20     public boolean removeObject(Object obj) {
    21         return this.list.remove(obj);
    22     }
    23     
    24     /**
    25      * 获得正向遍历的迭代器对象
    26      * @return
    27      */
    28     public MyIterator creatIterator() {
    29         return new ConcreteIterator(0);
    30     }
    31     
    32     /**
    33      * 获得逆向遍历的迭代器对象
    34      * @return
    35      */
    36     public MyIterator creatConverseIterator() {
    37         return new ConcreteIterator(list.size()-1);
    38     }
    39     
    40     /**
    41      * 自定义迭代器内部类
    42      * @author CL
    43      *
    44      */
    45     private class ConcreteIterator implements MyIterator {
    46         
    47         private int cursor;
    48         
    49         private final int firstValue;
    50         
    51         public ConcreteIterator(int cursor) {
    52             this.cursor = cursor;
    53             this.firstValue = cursor;
    54         }
    55 
    56         @Override
    57         public boolean hasNext() {
    58             if (firstValue == 0) {    //正向遍历
    59                 if (cursor < list.size()) {
    60                     return true;
    61                 }
    62             } else if (firstValue == list.size()-1) {    //逆向遍历
    63                 if (cursor >= 0) {
    64                     return true;
    65                 }
    66             }
    67             return false;
    68         }
    69 
    70         @Override
    71         public Object next() {
    72             if (firstValue == 0) {    //正向遍历
    73                 if (cursor < list.size()) {
    74                     return list.get(cursor++);
    75                 }
    76             } else if (firstValue == list.size()-1) {    //逆向遍历
    77                 if (cursor >= 0) {
    78                     return list.get(cursor--);
    79                 }
    80             }
    81             return null;
    82         }
    83 
    84         @Override
    85         public void remove() {
    86             list.remove(cursor);
    87         }
    88     }
    89 }

测试：

1 /**
     2  * 测试迭代器对象
     3  * @author CL
     4  *
     5  */
     6 public class Client {
     7 
     8     public static void main(String[] args) {
     9         ConcreteAggregate ca = new ConcreteAggregate();
    10         ca.addObject("aa");
    11         ca.addObject("bb");
    12         ca.addObject("cc");
    13         ca.addObject("dd");
    14         
    15         System.out.println("正向遍历：");
    16         MyIterator it = ca.creatIterator();
    17         while (it.hasNext()) {
    18             System.out.println(it.next());
    19         }
    20         
    21         System.out.println("逆向遍历：");
    22         MyIterator it2 = ca.creatConverseIterator();
    23         while (it2.hasNext()) {
    24             System.out.println(it2.next());
    25         }
    26     }
    27 }

控制台输出：

正向遍历：
    aa
    bb
    cc
    dd
    逆向遍历：
    dd
    cc
    bb
    aa

#### 三、迭代器模式常见开发应用场景 ####

（1）JDK内置的迭代器（List / Set）

List / Set 实现了 Collection 接口，Collection 实现了 Iterator 接口。

（2）…………