JDK源码解析——深入函数式接口（应用篇一）--20210607

发表于 | 分类于 ，

Lambda表达式，相信大家都耳有所闻，而且不少小伙伴在日常的工作中也在使用。但说到函数式接口，可能有一些即使会使用Lambda表达式的小伙伴也会觉得陌生。今天，指北君就将带领大家对Lambda、及其所使用的一些和函数式接口相关的知识点进行一个全面的学习。 函数式接口所涉及的知识点包含：java.util.function包，@FunctoinInterface注解，Lambda表达式，双冒号操作符。同时，我们还将对函数式接口的实现原理进行深入的剖析。

概述

函数式接口将分为三个篇章来为大家介绍：

  • （应用篇一）（1）函数式接口的来源，（2）Lambda表达式，（3）双冒号运算符
  • （应用篇二）（4）详细介绍@FunctionInterface注解（5）对java.util.function包进行解读
  • （原理篇）介绍函数式接口的实现原理 应用篇将阶段相关的JDK源码以及给出典型的示例代码 原理篇则从编译、JVM维度来分析函数式接口的实现原理，具有一定深度，需要读者具备一定的底层知识。

说明：源码使用的版本为JDK-11.0.11

什么是函数式接口

【阅读导引】：本节为概念性知识，纯技术向伙伴可跳过

在分析具体内容之前，指北君带领大家来对函数式接口做个基本的认知。函数式接口是JAVA语言为引入函数式编程而增加的特性，也即是说函数式接口式Java实现函数式编程的具体方式。那么，函数式编程到底是什么？他和面向对象编程又有什么关系？它能为我们带来什么？我们又是否真的需要函数式编程？ 有很多小伙伴，可能和指北君一样，是以面向对象语言开启的编程世界的，对于函数式编程其实很陌生。所以，指北君在这里先给大家引荐编程界的三大流派（当然还有别的流派）：过程式，函数式，对象式：

编程范式

函数式编程的思想脱胎于数学理论，也就是我们通常所说的λ演算（λ-calculus）。这也是为什么Java8中引入的函数式编程叫Lambda表达式的原因吧。如同数学中的函数一样，函数式编程范式中的函数有独特的特性，也就是通常说的无状态或引用透明性。一个函数的输出由且仅由其输入决定，同样的输入永远会产生同样的输出。

函数式编程的定义：”函数式编程是一种编程范式。它把计算当成是数学函数的求值，从而避免改变状态和使用可变数据。它是一种声明式的编程范式，通过表达式和声明而不是语句来编程。” 函数式编程的代码通常更加简洁，但是不一定易懂。

近年来，随着多核平台和并发计算的发展，函数式编程的无状态特性，在处理这些问题时有着其他编程范式不可比拟的天然优势。这种发展也就进一步促使了Java引入函数式编程这一特性。

一个简单示例

指北君先给大家展示一个简单的函数式编程的示例：

1
2
3
4
5
6
7
8
9
10
11
  /**
   * 简单的函数式编程示例
   */
  public static void lambdaDemo1() {
    // 准备测试数据
    Integer[] data = new Integer[] {1, 2, 3};
    List<Integer> list = Arrays.asList(data);
    
    // 简单示例：转换单位并打印数据
    list.forEach(x -> System.out.println(String.format("Cents into Yuan: %.2f", x/100.0)));
  }

不熟悉Lambda表达式的小伙伴可能会好奇其中的语句：x -> System.out.println(String.format(“Cents into Yuan: %.2f”, x/100.0))，这是什么呢？这就是我们的Lambda表达式。 通常，我们要访问List对象，需要通过for、while等控制循环语句，并在循环中完成相关工作。有了函数式编程后，我们就可以使用Lambda表达式来完成对应的功能，是不是很简洁！ 小伙伴们可能会奇怪，难道Lambda自动做了循环？当然不是，这里的循环控制并没有减少，只是在forEach方法中而已。我们打开默认的迭代器forEach实现方法（ArrayList的forEach实现有差异，总体逻辑一致），代码显示forEach循环，并在循环中执行参数的函数逻辑。

1
2
3
4
5
6
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

既然没有省略控制逻辑，难道我们费这么大的力气引入这个东东就只是为了简洁点？指北君画了一下调用逻辑，参见下图 两种编程模式比较

从上图中大家是不是隐约可以看出：这种方式可以将控制部分和业务处理部分进行解耦，业务处理代码更容易集中。

我们在分析forEach源码的时候，看到forEach的参数类型为Consumer,打开Consumer源码（主要接口声明部分）：

1
2
3
4
@FunctionalInterface
public interface Consumer<T> {
  ...
}

小伙伴们是不是发现这就是一个简单的接口，接口使用了@FunctionInterface的接口，这是不是对Lambda表达式使用位置的约束呢？这个问题我们将在接下来的几个章节给出答案。

Lambda表达式

在示例部分，指北君展示了在Java中如何Lambda进行函数式编程，小伙伴们是不是跃跃欲试想要动手了呢？在动手之前指北君先带领大家了全面学习Lambda表达式的语法。 下面给出几种常见的Lambda代码片段（代码仅截取部分，无上下文）：

1
2
3
4
5
6
7
8
9
10
    () -> System.out.println("demo")
    ...
    list.forEach(x ->  System.out.print(x));
    ...
    map.forEach((x, y) -> {
      System.out.print(x);
      System.out.println(y);
    });
    ...
    (Integer x, String y) -> System.out.println("x: " + x ", y: " + y);

从上面代码片段，可以看出Lambda表达式是通过->操作符来连接的，左边为参数部分，右边为表达式主体。

Lambda表达式语法：

  1. (parameters)->expression
  2. (parameters)->{statements;}

参数说明： ([[type] parameter [, …]])

  • 参数包括在圆括号内，参数数量可以0到多个，多个参数通过逗号“,”分割，例如(x, y)->
  • 参数类型可明确声明，也可以省略，省略时根据上下问进行推断， 例如：(x)->, (int x)->
  • 无参数，直接使用括号，例如：()->
  • 一个参数时，且参数类型省略，则括号可以省略 x->

表达式主体：

  • 由0到多条语句组成
  • 只有一条语句时，语句块符号“{}”可省略，此时语句的结果将作为返回值，例如：->x*x, ->System.out.print(x)。
  • 超过一条语句时，必须使用语句块符号“{}”包含起来。
  • 带return关键字必须用代码块，例如：->{return x+x}。

常见的组合形式：

1
2
3
4
5
6
7
8
9
10
11
(int a, int b) -> {  return a + b; }

() -> System.out.println("Demo")

(String s) -> { 
  System.out.println(s); 
}

() -> 42

() -> { return 3.1415 };

启动线程

1
2
3
new Thread(
    () -> System.out.println("start in thread.")
).start();

其他的代码遵循基本的Java语法，小伙伴们现在就可以大展拳脚，试试通过Lambda表达式进行函数式编程。

双冒号操作符

经过上一节的实践，小伙伴们是不是很兴奋了，可能有些小伙伴会问，Java类中的的方法也是函数，我可不可以在传入Lambda表达式的地方传入普通方法呢？类似下面这种效果：

1
2
3
    List<String> list = new ArrayList<String>();
    ...
    list.forEach(xxxMethod());

想法是没有问题的，但是形式错误了，首先xxxMethod()会直接触方法执行，并且返回的类型也不匹配forEach方法。那么，正确的形式应该如何写呢？这就需要我们的双冒号云算法登场了。 双冒号云算符标准名称为eta-conversion，有下面四种常用场景

  1. 实例方法引用 object::instanceMethod
  2. 静态方法引用 Class::staticMethod
  3. 实例方法引用（实例作为参数传入） Class::instanceMethod
  4. 构造方法引用 Class:new
    • 无参数：Supplier
    • 一个参数：Function
    • 二个参数：BiFunction
    • 更多：自定义函数接口

示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public class FunctionInterfaceInvoke {

  public static void main(String[] args) {
    
    // 1-1 构造方法（无参数），编译会做参数检查（包含输入参数和返回值）
    Supplier<FunctionInterfaceInvoke> s = FunctionInterfaceInvoke::new;
    s.get();
    
    //1-2 构造方法（1个参数）
    IntFunction<FunctionInterfaceInvoke> func = FunctionInterfaceInvoke::new;
    func.apply(1);
    
    // 1-3 构造方法（多个参数）
    BiFunction<Integer, Integer, FunctionInterfaceInvoke> func2 = FunctionInterfaceInvoke::new;
    func2.apply(1, 2);
    
    // 2 静态方法
    Consumer<Integer> sta1 = FunctionInterfaceInvoke::staticMethod;
    sta1.accept(1);
    
    // 3 实例方法
    IntConsumer sta2 = new FunctionInterfaceInvoke()::instanceMethod;
    sta2.accept(2);

  }

  public FunctionInterfaceInvoke() {
    System.out.println("none parameters");
  }
  
  public FunctionInterfaceInvoke(int p1) {
    System.out.println("constructor whith one parameter: " + p1);
  }
  
  public FunctionInterfaceInvoke(Integer p1, Integer p2) {
    System.out.println(String.format("constructor whith 2 parameters %1s, %2s", p1, p2));
  } 
  
  public static void staticMethod(Integer p1) {
    System.out.println("static method:" + p1);
  }
  
  public void instanceMethod(int p1) {
    System.out.println("instance method:"+p1);
  }
}

小结

函数式接口应用篇的第一部分就给大家介绍到这里，本篇我们介绍了什么是函数式编程，一个简单示例，Lambda表达式详细说明和双冒号操作的使用。下一篇我们将会继续介绍函数式接口的应用，学习 @FunctionInterface注解和java.util.function包中的接口。

最后感谢各位小伙伴的点赞、收藏和评论，我们下期更精彩。

Java Geek Tech wechat
欢迎订阅 Java 技术指北，这里分享关于 Java 的一切。