# 写在前面前面说过，判断一门语言是否支持函数式编程，一个重要的判断标准就是：它是否将函数看做是“第一等公民（first-class citizens）”。函数是“第一等公民”，意味着函数和其它数据类型具备同等的地位——可以赋值给某个变量，可以作为另一个函数的参数，也可以作为另一个函数的返回值。 Java 8是通过函数式接口，赋予了函数“第一等公民”的特性。本文将详细介绍Java 8中的函数式接口。本文的示例代码可从gitee上获取，完整专栏文章获取，可关注公众号【员说】。 # 函数式接口什么是函数式接口（function interface）？只有一个抽象方法的接口都属于函数式接口。按照规范，我们强烈建议在定义函数式接口时，加上注解 @FunctionalInterface，这样在编译阶段就可以判断该接口是否符合函数式接口的规范。当然，也可以不加注解 @FunctionalInterface，这并不影响函数式接口的定义和使用。以下是一个典型的函数式接口 Consumer： ```java // 强烈建议加上注解 @FunctionalInterface @FunctionalInterface public interface Consumer { // 唯一的抽象方法 void accept(T t); // 可以有多个非抽象方法（默认方法） default Consumer andThen(Consumer after) { Objects.requireNonNull(after); return (T t) -> { accept(t); after.accept(t); }; } } ``` 函数式接口本质是一个接口（interface），所以我们可以通过一个具体的类（包括匿名类）来实现一个函数式接口。但与普通接口不同，函数式接口的实现还可以是一个lambda表达式，甚至可以是一个方法引用（method reference）。下面，我们逐一介绍JDK中内置的一些典型的函数式接口。 # Java 8中内置的函数式接口 Java 8新增的内置函数式接口都在包 java.util.function 中定义，主要包括： ## 1. Functions ### Function 在代码世界，最为常见的一种函数式接口是接收一个参数值，然后返回一个响应值。JDK提供了一个标准的泛型函数式接口 Function: ```java @FunctionalInterface public interface Function { /** * 给定一个类型为 T 的参数 t ，返回一个类型为 R 的响应值。 * * @param t 函数参数 * @return 执行结果 */ R apply(T t); } ``` Function的一个经典应用场景是Map的computeIfAbsent函数。 ```java public V computeIfAbsent(K key, Function mappingFunction); ``` computeIfAbsent函数会先判断对应key在map中是否存在，如果key不存在，则通过参数 mappingFunction 来计算得出一个value，并将这个键值对写入到map中，并返回计算出来的value。如果key已存在，则返回map中key对应的value。假设一个应用场景，我们要构建一个HashMap，key是某个单词，value是单词的字母长度。实例代码如下： ```java public static void testFunctionWithLambda() { // 构建一个HashMap，key是某个单词，value是单词的字母长度 Map wordMap = new HashMap<>(); Integer wordLen = wordMap.computeIfAbsent("hello", s -> s.length()); System.out.println(wordLen); System.out.println(wordMap); } ``` 上面的实例会输出： ``` 5 {hello=5} ``` 注意到代码片段“s -> s.length()”，这是一个典型的lambda表达式，含义等同于函数： ```java public static int getStringLength(String s) { return s.length(); } ``` 更详尽具体的lambda表达式的介绍可以参考随后的系列文章。之前提到过，函数式接口也可以通过一个方法引用（method reference）来实现。实例代码如下： ```java public static void testFunctionWithMethodReference() { Map wordMap = new HashMap<>(); Integer wordLen = wordMap.computeIfAbsent("hello", String::length); System.out.println(wordLen); System.out.println(wordMap); } ``` 注意到方法引用“String::length”，Java 8允许我们将一个实例方法转化成一个函数式接口的实现。它的含义和 lambda 表达式 “s -> s.length()” 是相同的。更详尽具体的方法引用的介绍可以参考随后的系列文章。 ### BiFunction Function 限制了只能有一个参数，但两个参数的情形也非常常见，所以就有了BiFunction，它接收两个参数值，然后返回一个响应值。 ```java @FunctionalInterface public interface BiFunction { /** * 给定类型分别为 T 的参数 t 和类型为 U 的参数 u，返回一个类型为 R 的响应值。 * * @param t 第一个参数 * @param u 第二个参数 * @return 执行结果 */ R apply(T t, U u); ... } ``` Function的一个经典应用场景是Map的replaceAll函数。 ```java public void replaceAll(BiFunction function) ``` Map的replaceAll函数，会遍历Map中的所有Entry，通过BiFunction类型的参数 function 计算出一个新值，然后用新值替换旧值。假设一个应用场景，我们使用一个HashMap，记录了一些单词和它们的长度，接着产品经理提了一个新需求，要求对某些指定的单词，长度统一记录为0。实例代码如下： ```java public static void testBiFunctionWithLambda() { Map wordMap = new HashMap<>(); wordMap.put("hello", 5); wordMap.put("world", 5); wordMap.put("on", 2); wordMap.put("at", 2); // lambda表达式中的k和v，分别是Map中Entry的key和原值value。 // lambda表达式的返回值是一个新值value。 wordMap.replaceAll((k, v) -> { if ("on".equals(k) || "at".equals(k)) { // 对应单词 on 和 at，单词长度统一记录为 0 return 0; } else { // 其它单词，单词长度保持原值 return v; } }); System.out.println(wordMap); } ``` 上述代码的输出为： ``` {world=5, at=0, hello=5, on=0} ``` ## 2. Supplier 除了Function和BiFunction，还有一种常见的函数式接口是不需要任何参数，直接返回一个响应值。这就是Supplier： ```java @FunctionalInterface public interface Supplier { /** * 获取一个类型为 T 的对象实例。 * * @return 对象实例 */ T get(); } ``` Supplier的一个典型应用场景是快速实现了工厂类的生产方法，包括延时的或者异步的生产方法。实例代码如下： ```java public class SupplierExample { public static void main(String[] args) { testSupplierWithLambda(); } public static void testSupplierWithLambda() { final Random random = new Random(); // 生成一个随机整数 lazyPrint(() -> { return random.nextInt(100); }); // 延时3秒，生成一个随机整数 lazyPrint(() -> { try { System.out.println("waiting for 3s..."); Thread.sleep(3*1000); } catch (InterruptedException e) { // do nothing } return random.nextInt(100); }); } public static void lazyPrint(Supplier lazyValue) { System.out.println(lazyValue.get()); } } ``` 上述代码输出类似： ``` 26 waiting for 3s... 27 ``` ## 3. Consumers 如果说Supplier属于生产者，那与之相对的是消费者Consumer。 ### Consumer 与Supplier相反，Consumer 接收一个参数，而不返回任何值。 ```java @FunctionalInterface public interface Consumer { /** * 对给定的单一参数执行相关操作。 * * @param t 输入参数 */ void accept(T t); ... } ``` 示例代码： ```java public static void testConsumer() { List list = Arrays.asList("Guangdong", "Zhejiang", "Jiangsu"); // 消费 list 中的每一个元素 list.forEach(s -> System.out.println(s)); } ``` 上述代码的输出为： ``` Guangdong Zhejiang Jiangsu ``` ### BiConsumer 还有BiConsumer，语义和Consumer一致，不同的是BiConsumer接收2个参数。 ```java @FunctionalInterface public interface BiConsumer { /** * 对给定的2个参数执行相关操作。 * * @param t 第一个参数 * @param u 第二个参数 */ void accept(T t, U u); ... } ``` 示例代码： ```java public static void testBiConsumer() { Map cityMap = new HashMap<>(); cityMap.put("Guangdong", "Guangzhou"); cityMap.put("Zhejiang", "Hangzhou"); cityMap.put("Jiangsu", "Nanjing"); // 消费 map中的每一个(key, value)键值对 cityMap.forEach((key, value) -> { System.out.println(String.format("%s 的省会是 %s", key, value)); }); } ``` 上述代码的输出是： ``` Guangdong 的省会是 Guangzhou Zhejiang 的省会是 Hangzhou Jiangsu 的省会是 Nanjing ``` ## 4. Predicate Predicate 的含义是接收一个参数值，然后依据给定的断言条件，返回一个boolean值。它实质上一个特殊的 Function，一个指定了返回值类型为boolean的 Function。 ```java @FunctionalInterface public interface Predicate { /** * 根据给定参数，计算得到一个boolean结果。 * * @param t 输入参数 * @return 如果参数符合断言条件，返回 true，否则返回 false */ boolean test(T t); ... } ``` Predicate 的使用场景通常是用来作为某种过滤条件。实例代码： ```java public static void testPredicate() { List provinces = new ArrayList<>(Arrays.asList("Guangdong", "Jiangsu", "Guangxi", "Jiangxi", "Shandong")); boolean removed = provinces.removeIf(s -> { return s.startsWith("G"); }); System.out.println(removed); System.out.println(provinces); } ``` 上述代码是过滤掉以字母 G 开头的省份，输出为： ``` true [Jiangsu, Jiangxi, Shandong] ``` ## 5. Operators Operator 函数式接口是一种特殊的 Function，要求返回值类型和参数类型是相同的。和 Function/BiFunction 一样，Operators 也支持1个或2个参数。 ### UnaryOperator UnaryOperator 支持1个参数，UnaryOperator\ 等同于 Function\： ```java @FunctionalInterface public interface UnaryOperator extends Function { ... } ``` UnaryOperator的示例代码——将省份拼音转换大写与小写字母： ```java public static void testUnaryOperator() { List provinces = Arrays.asList("Guangdong", "Jiangsu", "Guangxi", "Jiangxi", "Shandong"); // 将省份的字母转换成大写字母 // 使用lambda表达式来实现 UnaryOperator provinces.replaceAll(s -> s.toUpperCase()); System.out.println(provinces); // 将省份的字母转换成小写字母。 // 使用方法引用(method reference)来实现 UnaryOperator provinces.replaceAll(String::toLowerCase); System.out.println(provinces); } ``` 上述代码输出为： ``` [GUANGDONG, JIANGSU, GUANGXI, JIANGXI, SHANDONG] [guangdong, jiangsu, guangxi, jiangxi, shandong] ``` ### BinaryOperator BinaryOperator 支持2个参数，BinaryOperator\ 等同于 BiFunction\ ```java @FunctionalInterface public interface BinaryOperator extends BiFunction { ... } ``` BinaryOperator的示例代码 —— 计算List中的所有整数的和： ```java public static void testBinaryOperator() { List values = Arrays.asList(1, 3, 5, 7, 11); // 使用 reduce 方法进行求和：0+1+3+5+7+11 = 27 int sum = values.stream() .reduce(0, (a, b) -> a + b); System.out.println(sum); } ``` 上述代码的输出为： ``` 27 ``` ## 6. Java 7及之前版本遗留的函数式接口前面提到过函数式接口的定义：只有一个抽象方法的接口都属于函数式接口。按照这个定义，在Java 7或之前版本中定义的一些“老”接口也属于函数式接口，包括： Runnable、Callable、Comparator等等。当然，这些遗留的函数式接口，在Java 8中也加上了注解 @FunctionalInterface 。 # 组合函数式接口我们在第一篇提到过：函数式编程是一种编程范式（programming paradigm），追求的目标是整个程序都由函数调用以及函数组合构成的。函数组合（function composing），指的是将一系列简单函数组合起来形成一个复合函数。 Java 8中的函数式接口也提供了函数组合的功能。大家注意观察，可以发现基本每个内置的函数式接口都有一个非抽象的方法 andThen。andThen方法的功能是将多个函数式接口组合在一起，以串行的顺序逐一执行，从而形成一个新的函数式接口。以Consumer.andThen方法为例，它返回一个新的Consumer实例。新的Consumer实例会先执行当前的accpet方法，然后再执行 after 的accpet方法。源码片段如下： ```java @FunctionalInterface public interface Consumer { ... default Consumer andThen(Consumer after) { Objects.requireNonNull(after); // 先执行当前Consumer的accept方法，再执行 after 的accept方法 // 特别要注意的是，accept(t) 不能写在 return 语句之前，否则accept(t)将会被提前执行 return (T t) -> { accept(t); after.accept(t); }; } ... } ``` 示例代码如下： ```java public static void testConsumerAndThen() { Consumer printUpperCase = s -> System.out.println(s.toUpperCase()); Consumer printLowerCase = s -> System.out.println(s.toLowerCase()); // 组合得到一个新的 Consumer ：先打印大写样式，再打印小写样式 Consumer prints = printUpperCase.andThen(printLowerCase); List list = Arrays.asList("Guangdong", "Zhejiang", "Jiangsu"); list.forEach(prints); } ``` 上述代码的输出是： ``` GUANGDONG guangdong ZHEJIANG zhejiang JIANGSU jiangsu ``` Function.andThen 方法则更复杂一些，它返回一个新的Function实例，在新的Function中，会先用类型为 T 的参数 t 执行当前的apply方法，得到一个类型为 R 的返回值 r，然后将 r 作为输入参数，继续执行 after 的apply方法，最终得到一个类型为 V 的返回值： ```java @FunctionalInterface public interface Function { default Function andThen(Function after) { Objects.requireNonNull(after); // 先用类型为 T 的参数 t 执行当前的apply方法，得到一个类型为 R 的返回值 r ； // 然后将 r 作为输入参数，继续执行 after 的apply方法，最终得到一个类型为 V 的返回值； // 特别要注意的是，apply(t) 不能写在 return 语句之前，否则apply(t)将会被提前执行。 return (T t) -> after.apply(apply(t)); } } ``` 代码示例： ```java public static void testFunctionAndThen() { // wordLen 计算单词的长度 Function wordLen = s -> s.length(); // 等同于 s -> { return s.length(); } // effectiveWord 单词长度大于等于4，才认为是有效单词 Function effectiveWordLen = len -> len >= 4; // Function 和 Function 组合得到一个新的 Function ， // 像是消消乐：遇到了，消去了 Integer 类型后，得到了。 Function effectiveWord = wordLen.andThen(effectiveWordLen); Map wordMap = new HashMap<>(); wordMap.computeIfAbsent("hello", effectiveWord); wordMap.computeIfAbsent("world", effectiveWord); wordMap.computeIfAbsent("on", effectiveWord); wordMap.computeIfAbsent("at", effectiveWord); System.out.println(wordMap); } ``` 上述代码输出为： ``` {at=false, world=true, hello=true, on=false} ``` # 结语 Java 8是通过函数式接口，赋予了函数“第一等公民”的特性。通过函数式接口，使得函数和其它数据类型一样，可以赋值给某个变量、可以作为另一个函数的参数、也可以作为另一个函数的返回值。函数式接口的实现，可以是一个类（包括匿名类），但更多的是一个lambda表达式或者一个方法引用（method reference）。