Java的23种设计模式---(13)迭代器模式

迭代器模式（iterator）

 

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

聚合对象：存储数据

迭代器：遍历对象

迭代器的角色构成：

1. 迭代器角色：定义遍历元素所需要的方法，如获取下一个元素的方法next()，判断是否遍历结束的方法hasNext()，移出当前对象的方法remove()
2. 具体迭代器角色：实现迭代器接口中定义的方法，完成集合的迭代。
3. 容器角色：一般是一个接口，提供一个iterator()方法。如：java中的Collection接口，List接口，Set接口
4. 具体容器角色：抽象容器的具体实现类。如：List接口有序列表实现ArrayList，List接口的链表实现linkList，Set接口的哈希列表的实现HashSet().

基本的案例有：正向遍历的迭代器和逆向的遍历的迭代器

 

现在实现正向遍历的迭代器案例

自定义聚合对象

package com.kevin.行为型模式.迭代器模式.iterator;

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

/**
 * @author kevin
 * @version 1.0
 * @description     自定的聚合类
 * @createDate 2019/3/3
 */
public class ConcreteMyAggregate {

    private List<Object> list = new ArrayList<Object>();

    public ConcreteMyAggregate() {}

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

    // 添加
    public void addObject(Object obj){
        this.list.add(obj);
    }
    // 删除
    public void removeObject(Object obj) {
        this.list.remove(obj);
    }
    // 获取
    public List<Object> getList() {
        return list;
    }
    // 修改
    public void setList(List<Object> list) {
        this.list = list;
    }

    // 获取迭代器
    public MyIterator createIterator() {
        return new ConreteIterator();
    }


    // 使用内部类定义迭代器，可以直接使用外部类的属性
    private class ConreteIterator implements MyIterator {

        private int cursor;     // 定义游标用于记录遍历时的位置

        @Override
        public void first() {
            // 第一个，设置游标为0
            cursor = 0;
        }

        @Override
        public void next() {
            // 下一个，判断是否为最后一个数据，如果不是则游标+1
            if(cursor<list.size()){
                cursor++;
            }
        }

        @Override
        public boolean hasNext() {
            // 是否存在下一个，判断游标是否小于list的长度，是则存在下一个
            if(cursor < list.size()){
                return true;
            }
            return false;
        }

        @Override
        public boolean isFirst() {
            // 是否为第一个，判断游标是否为0，是返回true，否则返回false
            return cursor == 0 ? true : false;
        }

        @Override
        public boolean isLast() {
            // 是否有最后一个，游标等于list的长度，是返回true，否则返回false
            return cursor == (list.size()-1) ? true : false;
        }

        @Override
        public Object getCurrentObj() {
            // 获取当前游标指向的对象
            return list.get(cursor);
        }
    }

}

自定义迭代器

package com.kevin.行为型模式.迭代器模式.iterator;

/**
 * @author kevin
 * @version 1.0
 * @description     自定义的迭代器接口
 * @createDate 2019/3/3
 */
public interface MyIterator {

    void first();   // 将游标指向第一个元素
    void next();    // 将游标指标下一个元素
    boolean hasNext();  // 判断是否存在下一个元素

    boolean isFirst();  // 判断是否为第一个元素
    boolean isLast();   // 判断是否为最后一个元素

    Object getCurrentObj(); // 获取当前游标指向的对象
}

测试迭代器模式

package com.kevin.行为型模式.迭代器模式;

import com.kevin.行为型模式.迭代器模式.iterator.ConcreteMyAggregate;
import com.kevin.行为型模式.迭代器模式.iterator.MyIterator;

/**
 * @author kevin
 * @version 1.0
 * @description     测试迭代器模式
 * @createDate 2019/1/18
 */
public class Test {

    public static void main(String[] args) {

        ConcreteMyAggregate cma = new ConcreteMyAggregate();
        cma.addObject("aa");
        cma.addObject("bb");
        cma.addObject("cc");

        MyIterator iter = cma.createIterator();
        while (iter.hasNext()){
            System.out.println(iter.getCurrentObj());
            iter.next();
        }

    }
}

开发中常见的场景：

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