设计模式——迭代器模式

Java架构师必看

发布于 2021-05-14 10:12:46

3610

发布于 2021-05-14 10:12:46

设计模式——迭代器模式

强烈推介IDEA2020.2破解激活，IntelliJ IDEA 注册码，2020.2 IDEA 激活码

在程序设计中，经常需要访问一个聚合对象中的各个元素，例如：我们使用 list 存储元素，通常的做法是将 list 的创建和遍历放在同一个类中。但这种方法不利于扩展，如果将存储方式更改为数组时，就需要更换迭代方式。违背了 “开闭原则”。“迭代器模式” 能较好的克服以上缺点，它在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与遍历行为，对客户也隐藏了其内部细节，满足 “单一职责原则” 和 “开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含迭代器。

一、迭代模式基本介绍

1）、迭代器模式（Iterator Pattern）：是常用的设计模式，属于行为型模式。 2）、如果集合元素是通过不同的方式实现的，有数组、list 等等，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。 3）、迭代器模式，提供了一种遍历集合元素的统一接口，用一致的方法遍历结合元素，不需要知道集合对象的底层表示，即：不暴露其内部的结构。 4）、缺点：每个聚合对象都要一个迭代器，增加了类的个数，在一定程度上增加了系统的复杂度且不好管理。 5）、提供了一种设计思想，就是一个类应该只有一个引起变化的原因（叫做 “单一责任原则”）。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到迭代器。

二、迭代器模式结构类图

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。

迭代器模式主要包含以下角色：【1】抽象聚合（Aggregate）角色：定义了存储、添加、删除聚合对象以及创建迭代对象的接口。【2】具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。【3】抽象迭代器（Iterator）角色：定义访问和遍历和聚合元素接口，通常包含 hasNext()、next()等方法。【4】具体迭代器（ConcreteIterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

三、迭代器模式案例分析

【1】抽象迭代器：使用 JDK 自带的 Iterator 接口，我们将源码粘贴过来，无需自行实现。子类需要实现 hasNext 和 next 方法

public interface Iterator<E> {

    boolean hasNext();
    //使用泛型 E
    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

【2】具体迭代器：定义将 List 集合包装为 Iterator 遍历的对象 ListIterator

public class ListIterator implements Iterator<Object>{
    //定义一个 List 集合
    List<Phone> list;

    //构造器
    public ListIterator(List<Phone> list) {
        this.list = list;
    }

    //获取位数
    int index = 0;
    @Override
    public boolean hasNext() {
        if(list != null && list.size()>index) {
            return true;
        }else {
            return false;
        }
    }

    @Override
    public Object next() {
        Phone object = list.get(index);
        index+=1;
        return object;
    }

}

【3】具体迭代器：定义将数组集合包装为 Iterator 遍历的对象 ArrayIterator

public class ArrayIterator implements Iterator<Object>{
    //定义 电话数组
    Phone[] phones;
    //下标
    private int index = 0;
    //构造器
    public ArrayIterator(Phone[] phones) {
        this.phones = phones;
    }

    @Override
    public boolean hasNext() {
        if(phones[index] != null && phones.length > index) {
            return true;
        }else {
            return false;
        }
    }

    @Override
    public Object next() {
        Phone phone = phones[index];
        index+=1;
        return phone;
    }

}

【4】定义 List 与数组中存储的对象 Phone。

public class Phone {
    public String name;
    public String money;
    /**
     * @param name
     * @param money
     */
    public Phone(String name, String money) {
        super();
        this.name = name;
        this.money = money;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getMoney() {
        return money;
    }
    public void setMoney(String money) {
        this.money = money;
    }

}

【5】抽象聚合角色：手机的抽象接口 IPhone

public interface IPhone {
    //获取手机名称
    public String getName();
    //创建一个获取 Iterator 实例的方法
    public Iterator<Object> createIterator();
    //增加手机的方法
    public void add(String name,String type);
}

【6】具体聚合角色：小米手机集合类，通过 List 进行封装，并创建一个返回 Iterator 的方法，使用迭代的方式遍历。

public class XiaoMiPhoneImpl implements IPhone{
    //小米使用 list 存储产品
    private List<Phone> xiaoMis = new ArrayList<Phone>();
    //构造器
    public XiaoMiPhoneImpl() {
        add("红米", "1200");
        add("小米6", "2300");
        add("小米7", "3200");
    }

    @Override
    public String getName() {
        return "====小米手机====";
    }
    //创建遍历器
    @Override
    public Iterator<Object> createIterator() {
        return new ListIterator(xiaoMis);
    }
        //集合中添加小米产品
    @Override
    public void add(String name, String money) {
        xiaoMis.add(new Phone(name, money));
    }

}

【7】具体聚合角色：华为手机集合类，通过数组进行封装，并创建一个返回 Iterator 的方法，使用迭代的方式遍历。

public class HuaWeiPhoneImpl implements IPhone{
    //存储华为手机的数据
    Phone phone[];
    private int index = 0;

    //构造器
    public HuaWeiPhoneImpl() {
        phone = new Phone[5];
        add("荣耀", "1300");
        add("华为P8", "2000");
        add("华为P20", "8000");
    }

    @Override
    public String getName() {
        return "====华为手机====";
    }

    @Override
    public Iterator<Object> createIterator() {
        return new ArrayIterator(phone);
    }

    @Override
    public void add(String name, String money) {
        phone[index] = new Phone(name,money);
        index +=1;
    }

}

【8】构造一个数据的工厂类：将所有的品牌集合在一块，通过 Iterator 接口的方式进行遍历输出。

public class OutputImpl {
    //定义一个集合
    private List<IPhone> phones;

    //构造器
    public OutputImpl(List<IPhone> phones) {
        this.phones = phones;
    }

    //输入方法
    public void outPrit() {
        //先调用 list 自身带的迭代器 Iterator
        Iterator<IPhone> iterator = phones.iterator();
        // 调用hasNext 方法
        while(iterator.hasNext()) {
            IPhone iPhones = iterator.next();
            //手机品牌名称
            System.out.println(iPhones.getName());
            //遍历品牌的所有手机，使用我们自己实现的Iterator
            pritlnPhone(iPhones.createIterator());
        }
    }


    private void pritlnPhone(Iterator<Object> createIterator) {
        while(createIterator.hasNext()) {
            Phone phone = (Phone) createIterator.next();
            System.out.println("品牌="+phone.getName()+"-----金额="+phone.getMoney());
        }
    }

}

【9】客户端调用：创建手机品牌实体类，并将其组合在 List 中，调用输出工厂集合类即可。

public class Client {

    public static void main(String[] args) {
        //手机店集合
        List<IPhone> phones = new ArrayList<IPhone>();
        //创建华为手机 == 数组
        HuaWeiPhoneImpl huaWeis = new HuaWeiPhoneImpl();
        //创建小米手机 == list
        XiaoMiPhoneImpl xiaoMis = new XiaoMiPhoneImpl();

        //将其都加入到手机店集合
        phones.add(huaWeis);
        phones.add(xiaoMis);

        //调用公共的输入类
        OutputImpl outputImpl = new OutputImpl(phones);
        outputImpl.outPrit();
        /**
         * 结构如下：
         * ====华为手机====
        品牌=荣耀-----金额=1300
        品牌=华为P8-----金额=2000
        品牌=华为P20-----金额=8000
        ====小米手机====
        品牌=红米-----金额=1200
        品牌=小米6-----金额=2300
        品牌=小米7-----金额=3200
         */
    }

}

四、迭代器模式应用源码分析

分析一下 arrayList 的 iterator 的使用

【1】先了解下 ArrayList 的 Iterator 的使用：

public class IteratorDemo {

    public static void main(String[] args) {
        List<String> a = new ArrayList<>();
        a.add("t");// ..
        // 获取到迭代器
        Iterator<String> Itr = a.iterator();
        while (Itr.hasNext()) {
            System.out.println(Itr.next());
        }
    }

}

【2】进入 ArrayList 的源码：实现了 List 接口，实现了 Iterator 方法，返回遍历对象：Iterator。相当于具体聚合对象。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>
{
    ...
        public Iterator<E> iterator() {
        return new Itr();
    }
    ...
}

【3】进入 List 接口查看：发现包含一个 Iterator 的抽象方法。相当于抽象聚合对象

public interface List<E> extends Collection<E> {
    ...
    Iterator<E> iterator();
    ...
}

【4】我们进入返回的 Iterator 对象的类 Itr ，是 ArraList 类的内部类。查看 hasNext(）方法，会发现遍历的对象是 Object[] 数组，具体的迭代器类（实现 hasNext 和 Next 方法）

private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;

        public boolean hasNext() {
            return cursor != size;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor;
            if (i >= size)
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }

        ......
    }

【5】上述具体迭代器角色实现了 Iterator 接口，也就是抽象迭代器角色。与我们的案例中实现同一个接口，就不展示了。【6】源码类图展示：同时多添加了两个具体的实现类：KeyIterator 与 LinkedList