2021年9月28日-设计模式之迭代器模式

第十七章

一、模式简介

1）迭代器我们使用容器技术时经常使用，可以说是既熟悉又陌生，属于行为型模式

2）迪米特法则要求一个类应该暴露的信息越少越好，所以当我们的一个集合类想要遍历元素而不暴露内部结构就可以采取迭代器模式

3）迭代器提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素

模式基本类图：

所以迭代器模式非常简单，只需实现两个接口即可。因为不同的集合，它内部的数据结构是不一样的，所以每个具体的集合类应有自己的迭代器实现

二、模式实例

这两年垃圾分类越来越严格了，所以我们今天实现一个垃圾桶的类，它可以装一些垃圾。垃圾桶内垃圾需要使用迭代器遍历打印。

垃圾桶顶层接口 Dustbin

public interface Dustbin {
    String getName();
    void addRubbish(String name, String category);
    Iterator createIterator();
}

迭代器顶层接口 Iterator

public interface Iterator<T> {
    boolean hashNext();
    // 这里用的是泛型哦
    T next();
}

垃圾类

@Data
public class Rubbish {
    public String name;
    public String category;

    public Rubbish(String name, String category) {
        this.name = name;
        this.category = category;
    }

    @Override
    public String toString() {
        return name + " 分类: " + category;
    }
}

具体垃圾桶类以及迭代器实现

public class RecyclableDushbin implements Dustbin {
    private Rubbish[] dushbin;
    private int len;
    private int position;

    public RecyclableDushbin() {
        this.dushbin = new Rubbish[10];
        this.len = 10;
        this.position = 0;
    }

    @Override
    public String getName() {
        return "有害垃圾收集处";
    }

    @Override
    public void addRubbish(String name, String category) {
        Rubbish rubbish = new Rubbish(name, category);
        if (position >= len) {
            Rubbish[] newDushbin = Arrays.copyOf(this.dushbin, len * 2);
            this.dushbin = newDushbin;
            this.len = this.dushbin.length;
        }
        this.dushbin[position] = rubbish;
        position++;
    }

    @Override
    public Iterator createIterator() {
        return new RecyclableRubbishIterator(this.dushbin);
    }

    // 因为集合不同迭代器应该有不同的实现，所以做成内部类的形式
    private class RecyclableRubbishIterator implements Iterator<Rubbish> {
        private Rubbish[] rubbishes;
        private int position;

        public RecyclableRubbishIterator(Rubbish[] rubbishes) {
            this.rubbishes = rubbishes;
            this.position = -1;
        }

        @Override
        public boolean hashNext() {
            position++;
            if (rubbishes.length <= position
                    || rubbishes[position] == null) {
                return false;
            }
            return true;
        }

        @Override
        public Rubbish next() {
            if (rubbishes.length <= position) {
                return null;
            }
            return rubbishes[position];
        }
    }
}

测试类

public class IteratorTest {
    public static void main(String[] args) {
        RecyclableDushbin dushbin = new RecyclableDushbin();
        dushbin.addRubbish("易拉罐", "可回收");
        dushbin.addRubbish("塑料瓶", "可回收");
        dushbin.addRubbish("硬纸板", "可回收");
        System.out.println(dushbin.getName() + "存放的垃圾有: ");
        Iterator iterator = dushbin.createIterator();
        while (iterator.hashNext()) {
            System.out.println(iterator.next());
        }
    }
}



/********** result **********
有害垃圾收集处存放的垃圾有: 
易拉罐 分类: 可回收
塑料瓶 分类: 可回收
硬纸板 分类: 可回收
*********** result **********/

三、模式总结

优点：

• 提供了统一接口遍历对象，不用考虑集合类的内部结构，方便遍历。而且还隐藏了集合类的内部结构

缺点：

• 每个对象都需要一个迭代器，会有很多迭代器类