JAVA函数式编程（1）- 行为参数化

2018-01-31 本文已影响0人 1桶

什么是行为参数化？

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

行为参数化使我们的代码更灵活

让我一个简单的例子来说明一些具体的做法，看我们是如何通过行为参数化让我们的代码越来越灵活。现在假如我们面对这样一个问题：从一个列表中筛选出颜色是绿色的苹果。

筛选绿苹果

按照我们的传统思维，第一个解决方案可能是这样的：

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

现在我们的问题改变了，还想筛选红苹果，我们最简单的做法就是复制这个方法，把名字改成filterRedApples，然后更改if条件来匹配红苹果。然而，要是我们想选多种颜色：浅绿色、暗红色、黄色等，这种方法就应付不了了。一个良好的原则就是在编写类似的代码之后，尝试将其抽象化。

将颜色作为参数

我们现在把颜色变成一个传入参数，就可以灵活地适应以上的需求变化了。

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

现在只需传入不同的颜色参数，我们的方法就能为我们筛选出对应颜色的苹果。

List<Apple> greenApples = filterApplesByColor(inventory, "green");
List<Apple> redApples = filterApplesByColor(inventory, "red");

太简单了对吧？此时我们的需求又变了，我们除了要筛选苹果的颜色外我们还需要筛选苹果的轻重，我们需要找出重量大于150g的苹果。于是你写下了下面的方法，用一个重量参数来作为比较的对象。

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

解决方案看上去不错，但是请你对比一下filterApplesByWeight和filterApplesByColor两个方法，是不是觉得他们太相似了？我们写了大量重复的代码来实现遍历的工作，真正有区别的仅仅是应用筛选条件的那一行，这和我们代码整洁的原则是相违背的，因为我们在重复。现在你可以将颜色和重量结合为一个方法，称为filter，然后通过一个标志位来区分对颜色和重量的查询，于是我们的代码变成了这样。

加入标志位，对不同的属性进行筛选

又一个看似灵活却很丑陋的方法诞生了：

public static List<Apple> filterApples(List<Apple> inventory, String color, Integer weight, Boolean flag) {
    List<Apple> result = new ArrayList<Apple>();
    for (Apple apple : inventory) {
        if ((flag && apple.getColor().equals(color)) ||
                (!flag && apple.getWeight() > weight)) {
            result.add(apple);
        }
    }
    return result;
}

这个方法确实太丑了，首先从我们调用它的代码就看的出来：

List<Apple> greenApples = filterApples(inventory, "green", 0, true);
List<Apple> heavyApples = filterApples(inventory, "", 150, false);

这两行代码可读性极差，true和false分别代表什么意思？只有查看实现才能明白，而且我们的color和weight参数总有一个是没有意义的，更重要的是即便如此我们的方法仍然无法很好地应对变化的需求。现在如果我们的需求变为对苹果的不同属性做筛选，比如大小、形状、颜色、产地等，又应该怎么办？而且如果要求你组合其中的两个甚至更多的属性，做更复杂的查询，又该怎么办？你会被迫去生产更多更丑陋的filter函数。下面让我们来看看如何利用行为参数化的方法来使我们的filter方法更灵活、更优雅。

行为参数化

让我们来看看更高层次的抽象，一种可能的解决方案是对你的选择标准进行建模：你考虑的是苹果，需要根据Apple的某些属性来返回一个布尔值，于是我们设计了这样一个接口:

public interface ApplePredicate {
    Boolean test(Apple apple);
}

我们给这个接口添加两个实现，分别用于筛选重量大于150g和颜色是绿色的苹果。

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

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

现在你可以通过AppleHeavyWeightPredicate和AppleGreenColorPredicate这两个实现类代表不同的选择标准了，你可以把这些标准看作filter方法的不同行为，通过传入不同的标准使得filter的行为发生改变。
利用ApplePredicate过后filter方法变成了这样：

public static List<Apple> filterApples(List<Apple> inventory , ApplePredicate predicate){
    List<Apple> result = new ArrayList<Apple>();
    for (Apple apple : inventory) {
        if (predicate.test(apple)){
            result.add(apple);
        }
    }
    return result;
}

现在你只需要让你的filterApple方法接受ApplePredicate接口的对象，就可以对Apple做筛选的测试了，而你的filterApple方法将不会随之改变！因为你把filterApples方法迭代集合的逻辑与你想要应用到集合中每个元素的行为分开了，这就是行为参数化：

让方法接受多种行为作为参数，并在内部使用，来完成不同的行为。

目前为止，我们已经让我们的代码变得优雅了许多，但是我们仍然面临着一个问题：每当筛选的条件变更时，我们需要实现一个新的ApplePredicate类来定义筛选的行为，这样会不会太啰嗦了？答案是肯定的，并且这种啰嗦是不必要的。

对付啰嗦

我们都知道java有一个机制成为匿名类，让你可以同时声明和示例化一个类。它可以让我们进一步改善我们的代码，让它变得更简洁。

使用匿名类

下面的代码展示了如何通过创建一个匿名类实现ApplePredicate对象。

List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
    public Boolean test(Apple apple) {
        return"red".equals(apple.getColor());
    }
});

好的代码应该是一目了然的，即使匿名类的出现在某种程度上改善了为一个接口声明好几个实体类的啰嗦问题，但它仍然不能令人满意：

它还是很笨重，包括new语句在内，还有一堆模版化的代码存在。
它的可读性还是很差，很多程序员觉得它看上去令人费解。

我们的业务场景中只需要传递一段简单的代码，那就是if语句所判定的条件，但在使用匿名类时仍然需要创建一个接口的对象，明确地实现一个方法来定义一个新的行为。
那有没有更加简洁的方法来传递这一段代码呢？Java8中引入的Lambda表达式就恰好完美的解决了这一问题。

使用Lambda表达式

上面的代码在Java8里可以使用Lambda表达式写为下面的样子：

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

是不是这行代码比之前的匿名类版本代码简洁了许多？因为它看起来更像是问题陈述本身了，并且它不需要声明更多的模版代码，在解决了啰嗦的同时可读性也大大提高了。
当然我们并不只满足于筛选“红苹果”这一简单的抽象，我们还可以更加进一步的将test方法给抽象成范型版本，从而超越苹果的概念，用于处理任意的类型。

终极目标，万能的filter方法

将我们的Predicate接口和filter方法都范型处理：

//范型版Predicate
public interface Predicate<T> {
    Boolean test(T t);
}

//范型版filter
public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<T>();
    for (T e : list) {
        if (predicate.test(e)) {
            result.add(e);
        }
    }
    return result;
}

现在你可以将filter方法用在任意你所想要筛选的对象列表上了：

//筛选小橙子
List<Orange> smallOranges =
        filter(inventory, (Orange orange) -> "orange.getSize()<=10");
//筛选偶数
List<Integer> evenNumbers =
        filter(numbers, (Integer i) -> i % 2 == 0);

现在我们终于在灵活性和简洁性之间找到了最佳平衡点，不是吗？而这一切都得益于Lambda函数的强大威力，我们将在今后的章节中专门介绍Lambda函数的特性，敬请期待。