《Java8 实战》-读书笔记第二章

[NGLSL]

通过行为参数化传递代码

行为参数化

在《 Java8 实战》第二章主要介绍的是通过行为参数化传递代码，那么就来了解一下什么是行为参数化吧。

在软件工程中，一个从所周知的问题就是，不管你做什么，用户的需求总是会变的（ PM 的需求总是会变的）。比方说，有个应用程序是帮助农民了解自己的库存。这位农民可能想有一个查找库存中所有绿色苹果的功能。但是到了第二天，他突然告诉你：“其实我还想找出所有重量超过 150 克的苹果。”，你一想简单嘛不就是改一下条件而已。于是过了两天，他又说：“要是我可以筛选即使绿色的苹果，重量也超过 150 克的苹果。”，这样频繁的改需求也不太好，面对这样的情况理想状态下应该把工作量降到最低。此外，类似的功能实现起来应该还是很简单，而且利于长期维护。

行为参数化就是要帮助你处理频繁更变的需求的一种软件开发模式。一言以蔽之，它意味着拿出一个代码块，把它准备好却不去执行它。这个代码块以后可以被你程序的其他部分调用，这意味着你可以推迟这块代码的执行。例如，你可以将代码块作为参数传递给另外一个方法，稍后再去执行它。这样，这个方法的行为就基于那块代码被参数化了。

应对不断变化的需求

想要编写能应对变化的需求并不容易。让我们来看一个例子，我们将会逐渐的改进这个例子，以展示一些让代码更灵活的做法。就像农场库存程序而言，你需要实现一个从列表中筛选绿苹果的功能。

筛选苹果

1. 筛选绿苹果，可能你选择最初的解决方案就是这样：

private static List<Apple> filterGreenApples(List<Apple> apples) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if ("green".equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}

现在代码中就是筛选绿苹果。但现在农民改主意了，他还想要筛选红苹果。按照最简单的方法就是，把方法复制一下并且改一下条件为筛选红苹果的条件。是的，这样做起来很简单，要是农民想要筛选多种颜色：青色、深红、淡红...这种方法就不太适合了。

1. 优化代码，通过颜色作为参数筛选苹果：

private static List<Apple> filterApplesByColor(List<Apple> apples, String color) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (color.equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}

很简单对吧。现在，农民又有想法：“能筛选出轻苹果和重苹果就好啦！一般重苹果的重量是 150 克。”你可能早就想到了需要通过重量来筛选苹果，于是你又把参数穿进来作为条件进行筛选。

1. 将重量作为参数，进行重苹果筛选：

private static List<Apple> filterApplesByWeight(List<Apple> apples, int weight) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (apple.getWeight() > weight) {
            appleList.add(apple);
        }
    }
    return appleList;
}

是的，解决方法很简单，但是你复制了大部分的代码来实现遍历库存，并对每个苹果应用筛选条件。这样破坏了 DRY(Don't Repeat Yourself 不要重复自己)的软件工程原则。或许，你一下就想到了这办法，将所有的参数都放在一个方法中，这样就可以简化很多代码了。

1. 第三次尝试，对你能想到的每个属性做筛选：

private static List<Apple> filterApples(List<Apple> apples, String color, int weight, boolean flag) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        boolean result = (flag && apple.getWeight() > weight) || (!flag && color.equals(apple.getColor()));
        if (result) {
            appleList.add(apple);
        }
    }
    return appleList;
}

代码看起来很简单，但是感觉却是不太好。如果不把注释写清楚，别人阅读你代码时根本就不知道 flag 是干嘛用的。要是，农民突然又有个想法，需用通过大小、形状、产地等条件来进行筛选怎么办？所以，我们需要利用行为参数化来解决这个问题，提高代码的灵活性。

行为参数化

目前，你需要一种比添加很多参数更好的方法来应对变化的需求。让我们退一步来看看更高层次的抽象。一种可能解决方案是对你的悬着标准建模：你考虑的是苹果，需要根据 Apple 的某些属性（比如它是绿色的吗？重量超过 150 克吗？）来返回一个 boolean 值。是的，你可能已经想到了第一章中介绍到了的谓词。

根据谓词进行筛选

首先，我们应该定义一个接口来对选择标准建模：

public interface ApplePredicate {
    /**
     * 根据给定的参数计算此谓词。
     *
     * @param apple
     * @return
     */
    boolean test(Apple apple);
}

可以用 ApplePredicate 的实现类来代表不同的选择标准：

只筛选绿苹果

public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}

只筛选重苹果

public class AppleHeavyWeightPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}

你可以把这些标准看作 filter 的不同行为。这就像策略设计模式一样，它让你定义一组方法，把它们封装起来，然后在运行时选择一个方法。这里，方法就是 ApplePredicate，不同的策略就是 AppleHeavyWeightPredicate 和 AppleGreenColorPredicate。

你可以将 filterApples 方法接受一个 ApplePredicate 对象，对 Apple 做条件测试。这样就是行为参数化：让方法接受多种行为作为参数，并在内部使用，来完成不同的行为。

根据抽象条件筛选

private static List<Apple> filterApples(List<Apple> apples, ApplePredicate<Apple> applePredicate) {
    List<Apple> appleList = new ArrayList<>();
    for (Apple apple : apples) {
        if (applePredicate.test(apple)) {
            appleList.add(apple);
        }
    }
    return appleList;
}

代码的传递 /行为

酷，这段代码看起来很多了，读起来、用起来也更容易！现在你可以创建不同的 ApplePredicate 对象，并将它们传递给 filterApples 方法。这样就可以根据不同的条件来创建一个类并且实现 ApplePredicate 就可以了。

现在，农民要求需要筛选红苹果。那么，我们就可以根据条件创建一个类并且实现 ApplePredicate：

public class AppleRedAndHeavyPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor()) && apple.getWeight() > 150;
    }
}

List<Apple> filterApples2 = filterApples(apples, new AppleRedAndHeavyPredicate());
System.out.println("通过谓词筛选红苹果并且是重苹果:" + filterApples2);

酷，现在 filterApples 方法的行为已经取决于通过 ApplePredicate 对象来实现了。这就是行为参数化了！

但是，你有没有发现，我们每次新增一个条件就需要新增一个类。这样做有点太过于麻烦，或许我们可以通过 Lambda，将表达式传递给 filterApples 方法，这样就无需定义多个 ApplePredicate 类，从而去掉不必要的代码，并减轻工作量。

多种行为，一个参数

行为参数化的好处在与你可以把迭代要筛选的集合的逻辑与对集合中每个元素应用的行为区分开来。这样你就可以重复使用同一个方法，给它不同的行为来达到不同的目的。

为了能够对参数化行为运用自如，并且简化代码，我们来尝试将参数通过 Lambda 的方式传递给 filterApples。

通过 Lambda 的方式来筛选红苹果:

List<Apple> filterApples3 = filterApples(apples, apple -> "red".equals(apple.getColor()));

通过 Lambda 的方式来筛选红苹果并且是重苹果：

List<Apple> filterApples4 = filterApples(apples, apple -> "red".equals(apple.getColor()) && apple.getWeight() > 150);

是的，使用的已经还是原来的条件，并且不再需要根据不同的条件再去实现一个 ApplePredicate 类了，这样极大的简化了代码。但是，农民又有一个需求了：“现在，不只是需要对苹果进行筛选了，还需要对香蕉、橘子、草莓进行筛选了。”

但是，我们目前的代码只能够对苹果进行筛选而已，为了解决这个问题，我们可以将类型定义为泛型，这样就不只是只能对苹果进行筛选了。

使用谓词

其实，我们可以不需要去定义谓词，因为在 Java 中就一个了 Predicate 了，我们可以使用它并且实现我们的功能。

定义一个泛型的 filter 方法：

private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)) {
            result.add(t);
        }
    }
    return result;
}

这个方法是一个通用的筛选方法，不只是可以用于筛选苹果。

筛选重苹果:

List<Apple> heavyApples = filter(apples, (Apple apple) -> apple.getWeight() > 150);

筛选能被 2 整除的数：

List<Integer> numbers = Arrays.asList(10, 11, 8, 5, 1, 2, 29, 18);
List<Integer> integerList = filter(numbers, number -> number % 2 == 0);

是不是很酷？现在的代码简洁性和灵活性都很高，在 Java8 之前这些都是不可能做到的！

现在，你已经感觉到了行为参数化是一个很有用的模式，它能够轻松地适应不断变化的需求。在 Java 中很多方法都可以用不同的行为来参数化，比如使用 Comparator 排序，用 Runnable 执行一个代码块等等。

使用 Comparator 来排序：

apples.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

或者这样：

apples.sort(Comparator.comparing(Apple::getWeight));

使用 Runnable 执行某个代码块：

Thread t = new Thread(() -> System.out.println("HelloWorld"));

总结

1. 行为参数化，就是一个方法接受多个不同的行为作为参数，并在内部使用它们，完成不同行为的能力。
2. 行为参数化可以让代码更好的适应不断变化的要求，减轻工作量。
3. 传递代码，就是将新行为作为参数传递给方法。但在 Java8 之前这实现起来很啰嗦。为接口生命许多只是用一次的实体类而造成的啰嗦代码，在 Java8 之前采用匿名类来减少。
4. JavaAPI 包含了很多可以用不同行为进行参数化的方法，包括排序、线程等。

代码示例：

Github：chap2

公众号

[hexinxucxy]

apples.stream().filter(f->.getWeight() > 150).collect(Collectors.toList());

[hexinxucxy]

感觉这样方便一点

[NGLSL]

是的，这篇读书笔记主要是为了介绍行为参数化以及谓词的使用，目前文章还没有写到 Stream 的读书笔记，非常感谢你的评论！