Java 8 Lambda 表达式详解

时间  2019-11-07
标签 java lambda 表达式 详解 栏目 Java 繁體版
原文   原文链接

版权声明：本文由吴仙杰创做整理，转载请注明出处：http://www.javashuo.com/article/p-kqynqxyn-gp.htmljava

1. 引言

在 Java 8 之前，若咱们想要把某些功能传递给某些方法，总要去写匿名类。之前注册事件监听器的写法与下面的示例代码就很像：shell

manager.addScheduleListener(new ScheduleListener() {
    @Override
    public void onSchedule(ScheduleEvent e) {        
        // Event listener implementation goes here...
    }
});

这里咱们添加了一些自定义代码到 Schedule 监听器中，须要先定义匿名内部类，而后传递一些功能到 onSchedule 方法中。编程

正是 Java 在做为参数传递普通方法或功能的限制，Java 8 增长了一个全新语言级别的功能，称为 Lambda 表达式。segmentfault

2. 为何 Java 须要 Lambda 表达式

Java 是面向对象语言，除了原始数据类型之处，Java 中的全部内容都是一个对象。而在函数式语言中，咱们只须要给函数分配变量，并将这个函数做为参数传递给其它函数就可实现特定的功能。JavaScript 就是功能编程语言的典范（闭包）。数组

Lambda 表达式的加入，使得 Java 拥有了函数式编程的能力。在其它语言中，Lambda 表达式的类型是一个函数；但在 Java 中，Lambda 表达式被表示为对象，所以它们必须绑定到被称为功能接口的特定对象类型。闭包

3. Lambda 表达式简介

Lambda 表达式是一个匿名函数（对于 Java 而言并不很准确，但这里咱们不纠结这个问题）。简单来讲，这是一种没有声明的方法，即没有访问修饰符，返回值声明和名称。app

在仅使用一次方法的地方特别有用，方法定义很短。它为咱们节省了，如包含类声明和编写单独方法的工做。编程语言

Java 中的 Lambda 表达式一般使用语法是 (argument) -> (body)，好比：ide

(arg1, arg2...) -> { body }

(type1 arg1, type2 arg2...) -> { body }

如下是 Lambda 表达式的一些示例：函数式编程

(int a, int b) -> {  return a + b; }

() -> System.out.println("Hello World");

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

() -> 42

() -> { return 3.1415 };

3.1 Lambda 表达式的结构

Lambda 表达式的结构：

  • Lambda 表达式能够具备零个，一个或多个参数。
  • 能够显式声明参数的类型，也能够由编译器自动从上下文推断参数的类型。例如 (int a) 与刚才相同 (a)。
  • 参数用小括号括起来，用逗号分隔。例如 (a, b) 或 (int a, int b) 或 (String a, int b, float c)。
  • 空括号用于表示一组空的参数。例如 () -> 42。
  • 当有且仅有一个参数时，若是不显式指明类型，则没必要使用小括号。例如 a -> return a*a。
  • Lambda 表达式的正文能够包含零条，一条或多条语句。
  • 若是 Lambda 表达式的正文只有一条语句，则大括号可不用写，且表达式的返回值类型要与匿名函数的返回类型相同。
  • 若是 Lambda 表达式的正文有一条以上的语句必须包含在大括号（代码块）中，且表达式的返回值类型要与匿名函数的返回类型相同。

4. 方法引用

4.1 从 Lambda 表达式到双冒号操做符

使用 Lambda 表达式，咱们已经看到代码能够变得很是简洁。

例如，要建立一个比较器，如下语法就足够了

Comparator c = (Person p1, Person p2) -> p1.getAge().compareTo(p2.getAge());

而后，使用类型推断：

Comparator c = (p1, p2) -> p1.getAge().compareTo(p2.getAge());

可是，咱们可使上面的代码更具表现力和可读性吗？咱们来看一下：

Comparator c = Comparator.comparing(Person::getAge);

使用 :: 运算符做为 Lambda 调用特定方法的缩写，而且拥有更好的可读性。

4.2 使用方式

双冒号（::）操做符是 Java 中的方法引用。 当们使用一个方法的引用时，目标引用放在 :: 以前，目标引用提供的方法名称放在 :: 以后，即 目标引用::方法。好比：

Person::getAge;

在 Person 类中定义的方法 getAge 的方法引用。

而后咱们可使用 Function 对象进行操做：

// 获取 getAge 方法的 Function 对象
Function<Person, Integer> getAge = Person::getAge;
// 传参数调用 getAge 方法
Integer age = getAge.apply(p);

咱们引用 getAge，而后将其应用于正确的参数。

目标引用的参数类型是 Function<T,R>，T 表示传入类型，R 表示返回类型。好比，表达式 person -> person.getAge();，传入参数是 person，返回值是 person.getAge()，那么方法引用 Person::getAge 就对应着 Function<Person,Integer> 类型。

5. 什么是功能接口（Functional interface）

在 Java 中，功能接口（Functional interface）指只有一个抽象方法的接口。

java.lang.Runnable 是一个功能接口，在 Runnable 中只有一个方法的声明 void run()。咱们使用匿名内部类实例化功能接口的对象，而使用 Lambda 表达式，能够简化写法。

每一个 Lambda 表达式均可以隐式地分配给功能接口。例如，咱们能够从 Lambda 表达式建立 Runnable 接口的引用，以下所示：

Runnable r = () -> System.out.println("hello world");

当咱们不指定功能接口时，这种类型的转换会被编译器自动处理。例如：

new Thread(
    () -> System.out.println("hello world")
).start();

在上面的代码中，编译器会自动推断，Lambda 表达式能够从 Thread 类的构造函数签名（public Thread(Runnable r) { }）转换为 Runnable 接口。

@FunctionalInterface 是在 Java 8 中添加的一个新注解，用于指示接口类型，声明接口为 Java 语言规范定义的功能接口。Java 8 还声明了 Lambda 表达式可使用的功能接口的数量。当您注释的接口不是有效的功能接口时， @FunctionalInterface 会产生编译器级错误。

如下是自定义功能接口的示例：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doSomeWork();
}

正如其定义所述，功能接口只能有一个抽象方法。若是咱们尝试在其中添加一个抽象方法，则会抛出编译时错误。例如：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doWork();
    public void doMoreWork();
}

错误：

Error:(3, 1) java: 意外的 @FunctionalInterface 注释
  com.wuxianjiezh.demo.lambda.WorkerInterface 不是函数接口
    在 接口 com.wuxianjiezh.demo.lambda.WorkerInterface 中找到多个非覆盖抽象方法

一旦定义了功能接口，咱们就能够利用 Lambda 表达式调用。例如：

package com.wuxianjiezh.demo.lambda;

@FunctionalInterface
public interface WorkerInterface {

    public void doWork();
}

class WorkTest {

    public static void main(String[] args) {
        // 经过匿名内部类调用
        WorkerInterface work = new WorkerInterface() {
            @Override
            public void doWork() {
                System.out.println("经过匿名内部类调用");
            }
        };
        work.doWork();
        
        // 经过 Lambda 表达式调用
        // Lambda 表达式其实是一个对象。
        // 咱们能够将 Lambda 表达式赋值给一个变量，就可像其它对象同样调用。
        work = ()-> System.out.println("经过 Lambda 表达式调用");
        work.doWork();
    }
}

运行结果：

经过匿名内部类调用
经过 Lambda 表达式调用

6. Lambda 表达式的例子

6.1 线程初始化

线程能够初始化以下：

// Old way
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world");
    }
}).start();

// New way
new Thread(
    () -> System.out.println("Hello world")
).start();

6.2 事件处理

事件处理能够用 Java 8 使用 Lambda 表达式来完成。如下代码显示了将 ActionListener 添加到 UI 组件的新旧方式：

// Old way
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Hello world");
    }
});

// New way
button.addActionListener( (e) -> {
        System.out.println("Hello world");
});

6.3 遍例输出（方法引用）

输出给定数组的全部元素的简单代码。请注意，还有一种使用 Lambda 表达式的方式。

// old way
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
for (Integer n : list) {
    System.out.println(n);
}

// 使用 -> 的 Lambda 表达式
list.forEach(n -> System.out.println(n));

// 使用 :: 的 Lambda 表达式
list.forEach(System.out::println);

6.4 逻辑操做

输出经过逻辑判断的数据。

package com.wuxianjiezh.demo.lambda;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Main {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

        System.out.print("输出全部数字：");
        evaluate(list, (n) -> true);

        System.out.print("不输出：");
        evaluate(list, (n) -> false);

        System.out.print("输出偶数：");
        evaluate(list, (n) -> n % 2 == 0);

        System.out.print("输出奇数：");
        evaluate(list, (n) -> n % 2 == 1);

        System.out.print("输出大于 5 的数字：");
        evaluate(list, (n) -> n > 5);
    }

    public static void evaluate(List<Integer> list, Predicate<Integer> predicate) {
        for (Integer n : list) {
            if (predicate.test(n)) {
                System.out.print(n + " ");
            }
        }
        System.out.println();
    }
}

运行结果：

输出全部数字：1 2 3 4 5 6 7 
不输出：
输出偶数：2 4 6 
输出奇数：1 3 5 7 
输出大于 5 的数字：6 7

6.4 Stream API 示例

java.util.stream.Stream接口 和 Lambda 表达式同样，都是 Java 8 新引入的。全部 Stream 的操做必须以 Lambda 表达式为参数。Stream 接口中带有大量有用的方法，好比 map() 的做用就是将 input Stream 的每一个元素，映射成output Stream 的另一个元素。

下面的例子，咱们将 Lambda 表达式 x -> x*x 传递给 map() 方法，将其应用于流的全部元素。以后，咱们使用 forEach 打印列表的全部元素。

// old way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
for(Integer n : list) {
    int x = n * n;
    System.out.println(x);
}

// new way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
list.stream().map((x) -> x*x).forEach(System.out::println);

下面的示例中，咱们给定一个列表，而后求列表中每一个元素的平方和。这个例子中，咱们使用了 reduce() 方法，这个方法的主要做用是把 Stream 元素组合起来。

// old way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = 0;
for(Integer n : list) {
    int x = n * n;
    sum = sum + x;
}
System.out.println(sum);

// new way
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = list.stream().map(x -> x*x).reduce((x,y) -> x + y).get();
System.out.println(sum);

7. Lambda 表达式和匿名类之间的区别

  • this 关键字。对于匿名类 this 关键字解析为匿名类，而对于 Lambda 表达式，this 关键字解析为包含写入 Lambda 的类。
  • 编译方式。Java 编译器编译 Lambda 表达式时，会将其转换为类的私有方法，再进行动态绑定。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程