一 前言

节前买了一本《Java8实战》的书，大概浏览了一下，其实主要讲的是Java8的函数式编程，由于我们项目用RxJava和Scala，所以基本上了解函数式编程和命令式编程的区别。接下来几篇博客都是以笔记的形式记录书中内容。
放假期间详细看了第一部分内容（包括前三章），主要说的是Lambda表达式（这个是借鉴了C#，Python和Scala等语言的特性），引入这个就是为了语法的简洁。
现在通过书中代码例子梳理一下几个主要概念:行为参数化（behavior parameterization）、匿名类（Anonymous class），Lambda 表达式（Lambda expressions）、函数式接口（Functional interface）和方法引用（Method reference）等几个重要概念。

二 项目需求变化

老家种了几亩苹果，今年大丰收，我们把这些苹果数据信息化。

# 定义一个苹果数据集合
List<Apple> inventory = Arrays.asList(new Apple(80,"green"), new Apple(155, "green"), new Apple(120, "red"));

2.1 第一个需求，筛选出绿色的苹果

这个很好实现，就不多说了。

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

2.2 第二个需求，筛选红色的苹果

如果过几天需求有变了，要筛选黄色的苹果，不只要复制多少次代码，果断把颜色作为参数。

public static List<Apple> filterApplesByColor(List<Apple> inventory, String color){
        List<Apple> result = new ArrayList<>();
        for(Apple apple: inventory){
            if(apple.getColor().equals(color)){
                result.add(apple);
            }
        }
        return result;
    }
# 调用
List<Apple> greenApples = filterApplesByColor(inventory, "red");

2.3 第三个需求，筛选重量大于150g的苹果。

一般的写法如下

public static List<Apple> filterApplesByWeight(List<Apple> inventory, int weight){
        List<Apple> result = new ArrayList<>();
        for(Apple apple: inventory){
            if(apple.getWeight() > weight){
                result.add(apple);
            }
        }
        return result;
    }
# 调用
List<Apple> heavyApples = filterApplesByWeight(inventory, 150);

2.4 第四个需求，筛选重量大于150g和红色苹果

同志们继续重构，定义两个参数

public static List<Apple> filterApples(List<Apple> inventory, String color,int weight){
        List<Apple> result = new ArrayList<>();
        for(Apple apple: inventory){
            if(apple.getWeight() > weight||apple.getColor().equals(color){
                result.add(apple);
            }
        }
        return result;
    }
#调用
List<Apple> redApples = filterApples(inventory, "red",150);

三 代码重构

上面的需求很会变，如果客户需要筛选形状和产地时，需要继续重构
面向接口编程，封装行为，进行行为参数化，其实就是策略模式。

3.1 行为参数化（behavior parameterization）

# 定义个接口（只定义一个抽象方法的接口叫函数式接口）
interface ApplePredicate{
        public boolean test(Apple a);
    }
# 实现过滤重量行为的类
static class AppleWeightPredicate implements ApplePredicate{
        public boolean test(Apple apple){
            return apple.getWeight() > 150; 
        }
    }
# 实现筛选颜色行为的类
static class AppleColorPredicate implements ApplePredicate{
        public boolean test(Apple apple){
            return "green".equals(apple.getColor());
        }
    }
# 调用
public static List<Apple> filter(List<Apple> inventory, ApplePredicate p){
        List<Apple> result = new ArrayList<>();
        for(Apple apple : inventory){
            if(p.test(apple)){
                result.add(apple);
            }
        }
        return result;
    }       

3.2 匿名类（Anonymous class）

上面的代码还有点啰嗦，能不能再简单一点，使用匿名类

List<Apple> redApples2 = filter(inventory, new ApplePredicate() {
            public boolean test(Apple a){
                return a.getColor().equals("red"); 
            }
        });

3.3 使用Lambda 表达式

java 8引入了Lambda表达式，不用像匿名类那样，每个行为都写一个类模板，接下来我们继续简化代码。

List<Apple> greenApples = filter(inventory, (Apple a) -> "green".equals(a.getColor()));

3.4 使用方法引用更易读，更自然

上面的Lambda表达式代表了直接调用类的方法，方法引用被看做针对仅仅涉及单一方法的Lambda的语法糖。
有三种方式构建方法引用

• 指向静态方法的方法引用(例如Integer的parseInt方法，写作Integer::parseInt)。
• 指向任意类型实例方法的方法引用（假设（String s）->s.toUpperCase()可以写作String::toUpperCase）
• 指向现有对象的实例方法引用（假设你有一个局部变量Local local，用于存放Local类型对象。它有一个getValue()，则写法为local::getValue）
  —— Java 8实战

上面代码的简化，就是第一种构建方式，如下：
List<Apple> greenApples = filter(inventory, String::equals);

四 Java8 常用的函数式接口

Java8中对函数式接口的描述是只定义一个抽象方法的接口叫函数式接口。

函数式接口	函数描述符	原始类型特化
Predicate<T>	T >boolean	IntPredicate,LongPredicate,DoublePredicate
Consumer<T>	T->void	IntConsumer,LongConsumer,DoubleConsumer
Function<T,R>	T->R	IntFunction<R>,IntToDoubleFunction ....
Supplier<T>	()->T	BooleanSupplier,IntSupplier,LongSupplier
UnaryOperator<T>	T->T	IntUnaryOperator,LongUnaryOperator
BinaryOperator	(T,T)->T	IntBinaryOperator,LongBinaryOperator

参考文献

[1]《Java 8实战》