Java 8 新特性（一）lambda表达式

最新推荐文章于 2024-09-21 23:21:04 发布

乐百川

最新推荐文章于 2024-09-21 23:21:04 发布

阅读量441

点赞数

分类专栏： java 文章标签： java lambda 编程语言

本文链接：https://blog.csdn.net/u011054333/article/details/77855248

版权

java 专栏收录该内容

102 篇文章 1 订阅

订阅专栏

Java 9 好像也快出了，不过我连Java 8的新特性都还没认真研究过，所以这几篇文章就是来介绍Java 8的新特性的。首先，第一个重要的特性就是传说中的lambda表达式了，虽然初学可能觉得这东西很难理解，但是一旦学会了，你就会发现离不开它了。

在现代编程语言中，lambda表达式这个语言特性已经成为了标配。当然不同语言中的lambda表达式概念和实现形式可能会稍有差别。不过不管在哪种语言中，我们都可以把lambda表达式简单的理解为匿名函数。在Java中，lambda表达式和只有一个方法的接口是差不多的，所以这样的接口又叫做SAM接口（Single Abstract Method interfaces）。

初识lambda表达式

说了半天，下面先来看看实际例子吧。我们在编写多线程代码的时候，常常需要编写实现Runnable的类。有时候为了省事，我们会写成匿名内部类的形式。

Runnable task1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("任务一");
    }
};

匿名内部类不好理解，而且写起来也非常丑陋。由于Runnable接口内只有一个方法，所以它是一个SAM接口，我们可以用lambda表达式改写它。那么改写之后是什么样子的呢？不要惊讶，只需要一行代码。

Runnable task2 = () -> System.out.println("任务二");

因此，我们可以看到lambda表达式的简洁之处。下面就来详细介绍一下lambda表达式的形式。

lambda表达式形式

lambda表达式可以用在需要SAM接口对象的地方，由于编译器这时候知道所需要的接口和对应方法的签名。所以lambda表达式的类型声明可以省略，具体类型由编译器自行推断。lambda表达式的基本形式如下。

(参数列表) -> {方法体}

为了方便说明，我这里定义了一组接口，用于之后的lambda表达式实现。

@FunctionalInterface
interface Interface1 {
    void f();
}


@FunctionalInterface
interface Interface2 {
    void f(int a);
}

@FunctionalInterface
interface Interface3 {
    void f(int a, int b);
}

@FunctionalInterface
interface Interface4 {
    int f(int a, int b);
}

无参lambda

先来看看无参数的lambda表达式。特别地，如果方法体只有一行代码，可以省略方法体的大括号。

Interface1 interface1 = new Interface1() {
    @Override
    public void f() {
        System.out.println("f");
    }
};
Interface1 lambda1 = () -> {
    System.out.println("f");
};
//如果方法体只有一行代码，可以省略大括号
Interface1 lambda1a = () -> System.out.println("f");

多个参数的lambda

我们可以看到由于编译器可以进行类型推断，所以lambda表达式的参数列表不需要参数类型声明，而且由于我只有一行代码，所以大括号也省略了。

//多个参数lambda
Interface3 interface3 = new Interface3() {
    @Override
    public void f(int a, int b) {
        System.out.println(a + b);
    }
};
Interface3 lambda3 = (a, b) -> System.out.println(a + b);

带返回值的lambda

带返回值的lambda表达式其实和普通的一样，只不过需要在方法体的最后使用return语句。值得注意的是最后一个例子，如果方法体本身足够简单，可以直接将返回值表达式写在lambda表达式的右边，编译器也会正确对待这种情况。

//带有返回值的lambda
Interface4 interface4 = new Interface4() {
    @Override
    public int f(int a, int b) {
        return a + b;
    }
};
Interface4 lambda4 = (a, b) -> {
    return a + b;
};
Interface4 lambda4a = (a, b) -> a + b;

单个参数的lambda

如果lambda表达式只有一个参数，那么参数列表的小括号也可以省略，例如下面的第二个例子。下面第三个例子演示了另一个新语法方法引用，如果lambda表达式的形式是单个参数a -> 某个只有一个参数的方法(a)，那么就可以简写成方法引用的形式类::方法。方法引用是一个新语法，如果见到了不要奇怪，这也是正确的Java代码。

//一个参数的lambda
Interface2 interface2 = new Interface2() {
    @Override
    public void f(int a) {
        System.out.println(a);
    }
};
Interface2 lambda2 = (a) -> System.out.println(a);
Interface2 lambda2a = a -> System.out.println(a);
Interface2 methodReference = System.out::println;

函数接口

`@FunctionalInterface`注解

如果查看JDK源码的一些接口，会发现它们上面添加了@FunctionalInterface注解。例如上面提到的Runnable接口。

@FunctionalInterface
public interface Runnable {

    public abstract void run();
}

这个注解用于标注函数接口，也就是上面提到的SAM接口。如果一个接口中包含了不止一个方法，那么函数接口注解就会触发编译错误。这个功能类似于@Override注解。当然并不是说要使用lambda表达式必须标记这个注解，只要接口中只有一个方法，那么就可以使用lambda表达式。

其实函数接口可以包括不止一个方法，除了一个普通的抽象方法之外，函数接口还可以包含一个在java.lang.Object类中声明的方法。Java 8新增了默认方法特性，如果接口的实现类没有实现java.lang.Object类中的这些基本方法，那么就会调用java.lang.Object类中的实现作为默认实现。

@FunctionalInterface
interface Interface5 {
    void f();

    String toString();
}

预定义的函数接口

在java.util.function包下定义了大量预定义的函数接口，它们包含了各种各样的形式，基本涵盖了编程的各个方面。同学们最好对这些函数接口的形式稍作了解，以后碰到的时候就不会一头雾水了。

函数接口

lambda表达式应用

编写线程

前面提到了，可以使用lambda表达式简化线程代码的编写，不再需要冗长的匿名内部类。

//编写线程
Runnable task = () -> System.out.println("简单的任务");
Executor executor = Executors.newCachedThreadPool();
executor.execute(task);

编写比较器

比方说我们有一个学生类，有姓名和年龄两个字段。如果需要按照某种规则来进行排序，可以使用比较器Comparator接口来比较，利用lambda表达式同样可以简化这部分代码的编写。

class Student {
    private String name;
    private int age;
    //其余方法已省略
}

可以看到比较规则只需要一条lambda表达式即可传入，非常方便。后面两个例子是Comparator接口新增的工具方法，可以帮助我们简化比较代码的编写，这里使用了方法引用来简化代码。comparing等方法的返回值仍然是Comparator，所以可以链式调用进行多级比较。

List<Student> students = new ArrayList<>();
students.add(new Student("yitian", 25));
students.add(new Student("anna", 26));
students.add(new Student("wang5", 24));

students.sort((a, b) -> a.getAge() - b.getAge());
System.out.println(students);

students.sort(Comparator.comparing(Student::getName));
System.out.println(students);

students.sort(
        Comparator.comparing(Student::getName)
                .thenComparing(Student::getAge));
System.out.println(students);