结合JDK源码看设计模式——策略模式

前言：

现在电商已经成为我们生活中不可或缺的购物渠道，同时各大商家会针对不同的时间做出不同的折扣，这在我们看来就是一种营销手段，也是一种策略，今天我们就来讲讲JDK中的策略模式是怎么样的。

一、定义

　　定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化不会影响到使用算法的用户。可以用来消除大量的if...else结构。

二、适用场景

　1、系统有很多类，它们的区别仅在于它们的行为不同

　2、一个系统需要动态的在几种算法中选择一种

　　在这里稍微理解一下，策略模式其实和工厂模式很像，不过工厂模式是创建型的，是接收到指令来去创建相应的工厂，而策略模式是传入一个创建好的策略来实现具体行为。重点理解行为和算法。其实只不过是我们根据不同业务场景做出的不同反应，拿淘宝来说，双十一的促销活动力度最大，可能打到5折，而女王节一般只打到7折。针对这两种不同的对象，就有两种不同的行为或者不同的算法，在客户端调用时，可以直接传入对应的策略就能做出相应的行为。下面我们来具体看一下策略模式在JDK中的应用

三、Comparator中的策略模式

　　我们先来认清，策略模式中到底需要什么角色：

　　　　1、抽象策略角色

　　　　　　负责定义通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

　　　　2、策略实现类

　　　　　　不同的类实现具体不同的算法。

　　　　3、环境角色类

　　　　　　里面持有抽象策略角色的引用，然后客户端可以由具体的方法传不同参数或实现类进去得到不同算法。

　　我们现在直接看Arrays这个类

public class Arrays{
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }
}

　　Arrays就是一个环境角色类，这个sort方法你可以传一个新策略让Arrays根据这个方法来进行排序。就比如下面的测试类。

public class Test1 {

    public static void main(String[] args) {
        Integer []data ={12,2,3,2,4,5,1};
// 实现降序排序，返回-1放左边，1放右边，0保持不变
        Arrays.sort(data, (str1, str2) -> {
            if (str1.compareTo(str2) > 0) {
                return -1;
            } else {
                return 1;
            }
        });
        System.out.println(Arrays.toString(data)); //[12, 5, 4, 3, 2, 2, 1]
    }
}

　　这里是直接用lambda表达式进行重写Comparator接口中的compare方法，可以认为这里的lambda表达式就是具体的算法，可见Comparator充当的就是抽象策略角色。我上面说过，环境角色类应该持有抽象策略的引用来调用，Arrays类中的sort方法是直接传Comparator接口，如果是有自己的compare方法那么就会进入到下面这个方法

class TimSort<T> {
    static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                         T[] work, int workBase, int workLen) {
        assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

        int nRemaining  = hi - lo;
        if (nRemaining < 2)
            return;  // Arrays of size 0 and 1 are always sorted

        // If array is small, do a "mini-TimSort" with no merges
        if (nRemaining < MIN_MERGE) {
            int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
            binarySort(a, lo, hi, lo + initRunLen, c);
            return;
        }
    private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
                                                    Comparator<? super T> c) {
        assert lo < hi;
        int runHi = lo + 1;
        if (runHi == hi)
            return 1;

        // Find end of run, and reverse range if descending
        if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                runHi++;
            reverseRange(a, lo, runHi);
        } else {                              // Ascending
            while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                runHi++;
        }

        return runHi - lo;
    }
}

　　这里多说一下，上面的代码中最终会跑到countRunAndMakeAscending这个方法中。我们可以看见，只用了compare方法，所以在调用Arrays.sort方法只传具体compare重写方法的类就行，这也是Comparator接口中必须要子类实现的一个方法。

四、总结

　　其实学了这么多模式，你会发现这些模式的大体很相似，但是细究起来又不相似。策略模式是很容易和工厂模式弄混淆的。策略模式的核心就是不同的行为对应不同的算法，而工厂更多的是生产不同的产品，给产品规定好的参数和返回类型。