一、外观模式

外观模式：为子系统中的一系列接口提供一个统一的操作界面，faced模式定义了一个高层接口，这个接口使得子系统更加容易使用。

比如我们要邮寄一个快递，需要先检查是否有违禁物品，然后称重计算邮费，最后在运输。如果如果这些步骤都由客户去做的时候，客户体验会非常不好，如果遇到更复杂的系统，客户也不一定知道怎么做。所以我们新成立一个管理员，客户只用和管理员打交道，管理员负责控制调用各个子系统，和子系统的流程，那这就是外观模式。

二、迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

迭代器模式的核心是，再获取到集合中的一个元素的同时，获取到是否还有下一个元素以及下一个元素的位置，比如我们遍历集合常用的遍历方式就有迭代器遍历。

迭代器模式的优点是：1、不需要知道这些元素在集合中是如何表示及存储的，比如有的是数组存储，有的是链表存储，而我们用迭代器遍历的时候不用关心这些，而且遍历的效率都是一样的。2、用户可以使用多个迭代器同时遍历一个集合。

拓展：我们测试一个对于数组、ArrayList、LinkedList不同遍历方式的遍历效率：

import java.util.*;

public class Application {
    public static void main(String[] args) {
        List<String> result = new LinkedList<>();
        //遍历数组
        String[] strArr = new String[20000];
        for (int i = 0; i < strArr.length; i++) {
            strArr[i] = "数组中第"+ i +"个元素";
        }
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }
        long time2 = System.currentTimeMillis();
        result.add("通过下标遍历数组耗时：" + (time2 - time1));
        for(String s : strArr){
            System.out.println(s);
        }
        long time3 = System.currentTimeMillis();
        result.add("通过增强for循环遍历数组耗时：" + (time3 - time2));
        //遍历ArrayList
        List<String> arrayList = new ArrayList<>();
        for (int i = 0; i < 20000; i++) {
            arrayList.add("arrayList中第"+ i +"个元素");
        }
        long time4 = System.currentTimeMillis();
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
        long time5 = System.currentTimeMillis();
        result.add("通过下标遍历ArrayList耗时：" + (time5 - time4));
        Iterator<String> iterator = arrayList.iterator();
        long time6 = System.currentTimeMillis();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        long time7 = System.currentTimeMillis();
        result.add("通过迭代器遍历ArrayList耗时：" + (time7 - time6));
        for (String s : arrayList){
            System.out.println(s);
        }
        long time8 = System.currentTimeMillis();
        result.add("通过增强型for循环遍历ArrayList耗时：" + (time8 - time7));
        //遍历LinkedList
        List<String> linkedList = new LinkedList<>();
        for (int i = 0; i < 20000; i++) {
            linkedList.add("lindedList中第"+ i +"个元素");
        }
        long time9 = System.currentTimeMillis();
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        long time10 = System.currentTimeMillis();
        result.add("通过下标遍历linkedList耗时：" + (time10 - time9));
        Iterator<String> iterator1 = linkedList.iterator();
        long time11 = System.currentTimeMillis();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        long time12 = System.currentTimeMillis();
        result.add("通过迭代器遍历linkedList耗时：" + (time12 - time11));
        for (String s : linkedList){
            System.out.println(s);
        }
        long time13 = System.currentTimeMillis();
        result.add("通过增强型for循环遍历linkedList耗时：" + (time13 - time12));
        //输出结果
        for (String s : result){
            System.out.println(s);
        }
    }
}

程序运行结果为：

我们发现只有linkedList的不同遍历方式有巨大差异。