还看不懂同事的代码？Lambda 表达式、函数接口了解一下

当前时间：2019年 11月 11日，距离 JDK 14 发布时间（2020年3月17日）还有多少天？

// 距离JDK 14 发布还有多少天？
LocalDate jdk14 = LocalDate.of(2020, 3, 17);
LocalDate nowDate = LocalDate.now();
System.out.println("距离JDK 14 发布还有："+nowDate.until(jdk14,ChronoUnit.DAYS)+"天");

1. 前言

Java 8 早已经在2014 年 3月 18日发布，毫无疑问 Java 8 对 Java 来讲绝对算得上是一次重大版本更新，它包含了十多项语言、库、工具、JVM 等方面的十多项新特性。好比提供了语言级的匿名函数，也就是被官方称为 Lambda 的表达式语法（外界也称为闭包，Lambda 的引入也让流式操做成为可能，减小了代码编写的复杂性），好比函数式接口，方法引用，重复注解。再好比 Optional 预防空指针，Stearm 流式操做，LocalDateTime 时间操做等。

在前面的文章里已经介绍了 Java 8 的部分新特性。

1. Jdk14 都要出了，Jdk8 的时间处理姿式还不了解一下？

2. Jdk14都要出了，还不能使用 Optional优雅的处理空指针？

这一次主要介绍一下 Lambda 的相关状况。

2. Lambda 介绍

Lambda 名字来源于希腊字母表中排序第十一位的字母 λ，大写为Λ，英语名称为 Lambda。在 Java 中 Lambda 表达式（lambda expression）是一个匿名函数，在编写 Java 中的 Lambda 的时候，你也会发现 Lambda 不只没有函数名称，有时候甚至连入参和返回均可以省略，这也让代码变得更加紧凑。

3. 函数接口介绍

上面说了此次是介绍 Lambda 表达式，为何要介绍函数接口呢？其实 Java 中的函数接口在使用时，能够隐式的转换成 Lambda 表达式，在 Java 8中已经有不少接口已经声明为函数接口，如 Runnable、Callable、Comparator 等。

函数接口的例子能够看下 Java 8 中的 Runnable 源码（去掉了注释）。

package java.lang;

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

那么什么样子的接口才是函数接口呢？有一个很简单的定义，也就是只有一个抽象函数的接口，函数接口使用注解 @FunctionalInterface 进行声明（注解声明不是必须的，若是没有注解，也是只有一个抽象函数，依旧会被认为是函数接口）。多一个或者少一个抽象函数都不能定义为函数接口，若是使用了函数接口注解又不止一个抽象函数，那么编译器会拒绝编译。函数接口在使用时候能够隐式的转换成 Lambda 表达式。

Java 8 中不少有不少不一样功能的函数接口定义，都放在了 Java 8 新增的 java.util.function包内。下面是一些关于 Java 8 中函数接口功能的描述。

序号	接口 & 描述
BiConsumer	表明了一个接受两个输入参数的操做，而且不返回任何结果
BiFunction	表明了一个接受两个输入参数的方法，而且返回一个结果
BinaryOperator	表明了一个做用于于两个同类型操做符的操做，而且返回了操做符同类型的结果
BiPredicate	表明了一个两个参数的boolean值方法
BooleanSupplier	表明了boolean值结果的提供方
Consumer	表明了接受一个输入参数而且无返回的操做
DoubleBinaryOperator	表明了做用于两个double值操做符的操做，而且返回了一个double值的结果。
DoubleConsumer	表明一个接受double值参数的操做，而且不返回结果。
DoubleFunction	表明接受一个double值参数的方法，而且返回结果
DoublePredicate	表明一个拥有double值参数的boolean值方法
DoubleSupplier	表明一个double值结构的提供方
DoubleToIntFunction	接受一个double类型输入，返回一个int类型结果。
DoubleToLongFunction	接受一个double类型输入，返回一个long类型结果
DoubleUnaryOperator	接受一个参数同为类型double,返回值类型也为double 。
Function	接受一个输入参数，返回一个结果。
IntBinaryOperator	接受两个参数同为类型int,返回值类型也为int 。
IntConsumer	接受一个int类型的输入参数，无返回值 。
IntFunction	接受一个int类型输入参数，返回一个结果 。
IntPredicate	接受一个int输入参数，返回一个布尔值的结果。
IntSupplier	无参数，返回一个int类型结果。
IntToDoubleFunction	接受一个int类型输入，返回一个double类型结果 。
IntToLongFunction	接受一个int类型输入，返回一个long类型结果。
IntUnaryOperator	接受一个参数同为类型int,返回值类型也为int 。
LongBinaryOperator	接受两个参数同为类型long,返回值类型也为long。
LongConsumer	接受一个long类型的输入参数，无返回值。
LongFunction	接受一个long类型输入参数，返回一个结果。
LongPredicate	接受一个long输入参数，返回一个布尔值类型结果。
LongSupplier	无参数，返回一个结果long类型的值。
LongToDoubleFunction	接受一个long类型输入，返回一个double类型结果。
LongToIntFunction	接受一个long类型输入，返回一个int类型结果。
LongUnaryOperator	接受一个参数同为类型long,返回值类型也为long。
ObjDoubleConsumer	接受一个object类型和一个double类型的输入参数，无返回值。
ObjIntConsumer	接受一个object类型和一个int类型的输入参数，无返回值。
ObjLongConsumer	接受一个object类型和一个long类型的输入参数，无返回值。
Predicate	接受一个输入参数，返回一个布尔值结果。
Supplier	无参数，返回一个结果。
ToDoubleBiFunction	接受两个输入参数，返回一个double类型结果
ToDoubleFunction	接受一个输入参数，返回一个double类型结果
ToIntBiFunction	接受两个输入参数，返回一个int类型结果。
ToIntFunction	接受一个输入参数，返回一个int类型结果。
ToLongBiFunction	接受两个输入参数，返回一个long类型结果。
ToLongFunction	接受一个输入参数，返回一个long类型结果。
UnaryOperator	接受一个参数为类型T,返回值类型也为T。

（上面表格来源于菜鸟教程）

3. Lambda 语法

Lambda 的语法主要是下面几种。

1. (params) -> expression

2. (params) -> {statements;}

Lambda 的语法特性。

1. 使用 -> 分割 Lambda 参数和处理语句。
2. 类型可选，能够不指定参数类型，编译器能够自动判断。
3. 圆括号可选，若是只有一个参数，能够不须要圆括号，多个参数必需要圆括号。
4. 花括号可选，一个语句能够不用花括号，多个参数则花括号必须。
5. 返回值可选，若是只有一个表达式，能够自动返回，不须要 return 语句；花括号中须要 return 语法。
   1. Lambda 中引用的外部变量必须为 final 类型，内部声明的变量不可修改，内部声明的变量名称不能与外部变量名相同。

举几个具体的例子， params 在只有一个参数或者没有参数的时候，能够直接省略不写，像这样。

// 1.不须要参数，没有返回值，输出 hello
()->System.out.pritnln("hello");

// 2.不须要参数，返回 hello
()->"hello";

// 3. 接受2个参数(数字),返回两数之和 
(x, y) -> x + y  
  
// 4. 接受2个数字参数,返回两数之和 
(int x, int y) -> x + y  
  
// 5. 两个数字参数，若是都大于10，返回和，若是都小于10，返回差
(int x,int y) ->{
  if( x > 10 && y > 10){
    return x + y;
  }
  if( x < 10 && y < 10){
    return Math.abs(x-y);
  }
};

经过上面的几种状况，已经能够大体了解 Lambda 的语法结构了。

4. Lambda 使用

4.1 对于函数接口

从上面的介绍中已经知道了 Runnable 接口已是函数接口了，它能够隐式的转换为 Lambda 表达式进行使用，经过下面的建立线程并运行的例子看下 Java 8 中 Lambda 表达式的具体使用方式。

/**
 * Lambda 的使用，使用 Runnable 例子
 * @throws InterruptedException
 */
@Test
public void createLambda() throws InterruptedException {
    // 使用 Lambda 以前
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("JDK8 以前的线程建立");
        }
    };
   new Thread(runnable).start();
   // 使用 Lambda 以后
   Runnable runnable1Jdk8 = () -> System.out.println("JDK8 以后的线程建立");
   new Thread(runnable1Jdk8).start();
   // 更加紧凑的方式
   new Thread(() -> System.out.println("JDK8 以后的线程建立")).start();
}

能够发现 Java 8 中的 Lambda 碰到了函数接口 Runnable，自动推断了要运行的 run 方法，不只省去了 run 方法的编写，也代码变得更加紧凑。

运行获得结果以下。

JDK8 以前的线程建立
JDK8 以后的线程建立
JDK8 以后的线程建立

上面的 Runnable 函数接口里的 run 方法是没有参数的状况，若是是有参数的，那么怎么使用呢？咱们编写一个函数接口，写一个 say 方法接受两个参数。

/**
 * 定义函数接口
 */
@FunctionalInterface
public interface FunctionInterfaceDemo {
    void say(String name, int age);
} 

编写一个测试类。

/**
  * 函数接口，Lambda 测试
  */
 @Test
 public void functionLambdaTest() {
     FunctionInterfaceDemo demo = (name, age) -> System.out.println("我叫" + name + "，我今年" + age + "岁了");
     demo.say("金庸", 99);
 }

输出结果。

我叫金庸，我今年99岁了。

4.2 对于方法引用

方法引用这个概念前面尚未介绍过，方法引用可让咱们直接访问类的实例或者方法，在 Lambda 只是执行一个方法的时候，就能够不用 Lambda 的编写方式，而用方法引用的方式：实例/类::方法。这样不只代码更加的紧凑，并且能够增长代码的可读性。

经过一个例子查看方法引用。

@Getter
@Setter
@ToString
@AllArgsConstructor
static class User {
    private String name;
    private Integer age;
}
public static List<User> userList = new ArrayList<User>();
static {
    userList.add(new User("A", 26));
    userList.add(new User("B", 18));
    userList.add(new User("C", 23));
    userList.add(new User("D", 19));
}
/**
 * 测试方法引用
 */
@Test
public void methodRef() {
    User[] userArr = new User[userList.size()];
    userList.toArray(userArr);
    // User::getAge 调用 getAge 方法
    Arrays.sort(userArr, Comparator.comparing(User::getAge));
    for (User user : userArr) {
        System.out.println(user);
    }
}

获得输出结果。

Jdk8Lambda.User(name=B, age=18)
Jdk8Lambda.User(name=D, age=19)
Jdk8Lambda.User(name=C, age=23)
Jdk8Lambda.User(name=A, age=26)

4.3 对于遍历方式

Lambda 带来了新的遍历方式，Java 8 为集合增长了 foreach 方法，它能够接受函数接口进行操做。下面看一下 Lambda 的集合遍历方式。

/**
 * 新的遍历方式
 */
@Test
public void foreachTest() {
    List<String> skills = Arrays.asList("java", "golang", "c++", "c", "python");
    // 使用 Lambda 以前
    for (String skill : skills) {
        System.out.print(skill+",");
    }
    System.out.println();
    // 使用 Lambda 以后
    // 方式1,forEach+lambda
    skills.forEach((skill) -> System.out.print(skill+","));
    System.out.println();
    // 方式2，forEach+方法引用
    skills.forEach(System.out::print);
}

运行获得输出。

java,golang,c++,c,python,
java,golang,c++,c,python,
javagolangc++cpython

4.4 对于流式操做

得益于 Lambda 的引入，让 Java 8 中的流式操做成为可能，Java 8 提供了 stream 类用于获取数据流，它专一对数据集合进行各类高效便利操做，提升了编程效率，且同时支持串行和并行的两种模式汇聚计算。能充分的利用多核优点。

流式操做如此强大， Lambda 在流式操做中怎么使用呢？下面来感觉流操做带来的方便与高效。

流式操做一切从这里开始。

// 为集合建立串行流
stream()
// 为集合建立并行流
parallelStream()

流式操做的去重 distinct和过滤 filter。

@Test
public void streamTest() {
    List<String> skills = Arrays.asList("java", "golang", "c++", "c", "python", "java");
    // Jdk8 以前
    for (String skill : skills) {
        System.out.print(skill + ",");
    }
    System.out.println();
    // Jdk8 以后-去重遍历
    skills.stream().distinct().forEach(skill -> System.out.print(skill + ","));
    System.out.println();
    // Jdk8 以后-去重遍历
    skills.stream().distinct().forEach(System.out::print);
    System.out.println();
    // Jdk8 以后-去重，过滤掉 ptyhon 再遍历
    skills.stream().distinct().filter(skill -> skill != "python").forEach(skill -> System.out.print(skill + ","));
    System.out.println();
    // Jdk8 以后转字符串
    String skillString = String.join(",", skills);
    System.out.println(skillString);
}

运行获得结果。

java,golang,c++,c,python,java,
java,golang,c++,c,python,
javagolangc++cpython
java,golang,c++,c,
java,golang,c++,c,python,java

流式操做的数据转换（也称映射）map。

/**
  * 数据转换
  */
 @Test
 public void mapTest() {
     List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);
     // 数据转换
     numList.stream().map(num -> num * num).forEach(num -> System.out.print(num + ","));

     System.out.println();

     // 数据收集
     Set<Integer> numSet = numList.stream().map(num -> num * num).collect(Collectors.toSet());
     numSet.forEach(num -> System.out.print(num + ","));
 }

运行获得结果。

1,4,9,16,25,
16,1,4,9,25,

流式操做的数学计算。

/**
 * 数学计算测试
 */
@Test
public void mapMathTest() {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    IntSummaryStatistics stats = list.stream().mapToInt(x -> x).summaryStatistics();
    System.out.println("最小值：" + stats.getMin());
    System.out.println("最大值：" + stats.getMax());
    System.out.println("个数：" + stats.getCount());
    System.out.println("和：" + stats.getSum());
    System.out.println("平均数：" + stats.getAverage());
    // 求和的另外一种方式
    Integer integer = list.stream().reduce((sum, cost) -> sum + cost).get();
    System.out.println(integer);
}

运行获得结果。

获得输出
最小值：1
最大值：5
个数：5
和：15
平均数：3.0
15

5. Lambda 总结

Lamdba 结合函数接口，方法引用，类型推导以及流式操做，可让代码变得更加简洁紧凑，也能够借此开发出更增强大且支持并行计算的程序，函数编程也为 Java 带来了新的程序设计方式。可是缺点也很明显，在实际的使用过程当中可能会发现调式困难，测试表示 Lamdba 的遍历性能并不如 for 的性能高，同事可能没有学习致使看不懂 Lamdba 等（能够推荐来看这篇文章）。

文章代码已经上传到 https://github.com/niumoo/jdk-feature) 。

<完>

我的网站：https://www.codingme.net
若是你喜欢这篇文章，能够关注公众号，一块儿成长。
关注公众号回复资源能够没有套路的获取全网最火的的 Java 核心知识整理&面试资料。