java-设计模式-迭代器模式

设计模式-迭代器模式
    提供一种方法顺序访问一个聚合对象中各个元素，而有不暴露该对象的内部表示
    本质：控制访问聚合对象的元素，透明访问元素

这个模式其实我们很熟悉了，因为java中就有迭代器，而且我们用的也很多。

先上个类图：

用java List的迭代器解释下这个类图吧。

Aggregate 是个聚集的抽象类，对应的是List

ConcreteAggregate具体的聚合类，对应的是 ArrayList

Iterator 迭代抽象类 对应的就是java的 Iterator类

ConcreteIterator 具体迭代类，对应的就是 list.iterator() 获取的对象对应的类，看源码得知是ArrayList类里面的内部类 Itr()

我们先看看怎么用吧：

         System.out.println("java List使用迭代器");
        List<String> dataList = new ArrayList<>();
        dataList.add("3");
        dataList.add("2");
        dataList.add("5");
        Iterator iterator = dataList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

上述的结果是：

3
2
5

其实到这里，你已经大概知道迭代器是个什么东西，迭代器模式也不是很常用。

继续看看自定义迭代器的用法。

实体类：

public class Item {
    private String id;
    private String name;

    public Item(String id,String name){
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Item{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
    //getter and setter 省略

   
}

聚合类

就是一个集合，如果这个写出泛型，那么会更加通用

/**
 * item 聚合类
 */
public class ItemAggregate {
    //数据
    private List<Item> dataList;

    public ItemAggregate(){
        dataList = new ArrayList<>();
    }
    //getter and setter

    public List<Item> getDataList() {
        return dataList;
    }

    public void setDataList(List<Item> dataList) {
        this.dataList = dataList;
    }
}

自定义迭代器类：

import java.util.Iterator;
import java.util.function.Consumer;

public class ItemIterator implements Iterator<Item> {

    private ItemAggregate itemAggregate;
    private int index = 0;

    public ItemIterator( ItemAggregate itemAggregate){
        this.itemAggregate = itemAggregate;
    }

    @Override
    public boolean hasNext() {
        return itemAggregate.getDataList().size() > index;
    }

    @Override
    public Item next() {
        return itemAggregate.getDataList().get(index++);
    }

    @Override
    public void remove() {
        itemAggregate.getDataList().remove(index--);
    }

    @Override
    public void forEachRemaining(Consumer<? super Item> action) {
    }
}

测试：

        System.out.println("自定义迭代器");
        ItemAggregate itemAggregate = new ItemAggregate();
        itemAggregate.getDataList().add(new Item("1","name1"));
        itemAggregate.getDataList().add(new Item("2","name2"));
        itemAggregate.getDataList().add(new Item("3","name3"));
        ItemIterator itemIterator = new ItemIterator(itemAggregate);
        while (itemIterator.hasNext()){
            System.out.println(itemIterator.next());
        }

测试结果：

Item{id='1', name='name1'}
Item{id='2', name='name2'}
Item{id='3', name='name3'}

可以看到使用方法还是一样，都是很简单。