lambda表达式一篇就懂

一、概述

本文转载 Lambda表达式一篇足够，做了排版的优化，以及调整一些表达。最后给出了思考题的答案。

1、是什么

Lambda表达式是一个匿名函数，即没有函数名的函数。也可以理解成是一段可以传递的代码（将代码像数据一样进行传递），这样一来代码更加简洁。

2、为什么

• 代码简洁
• 可能还有一些优化，但是目前没研究，研究到的时候再来补充。

二、语法组成

param -> body

1. 中间以 -> 隔开形成左右两部分。我们称->为箭头操作符。
2. 表达式左边：Lambda表达式的参数列表。
3. 表达式右边：Lambda表达式中所需执行的功能，即Lambda体。

三、语法格式

1、无参无返回

方法没参数且没返回值，比如

public void test() {System.out.println("hello")}

用lambda表达式，首先看我们的Lambda组成公式：param -> body。无参就用()代替，那么就是() -> body，方法体是输出语句，所以：

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

别问我方法名称在哪？第一个就说了，匿名函数，即没有函数名的函数。

2、一参无返回

方法有一个参数且没返回值，比如：

public void test(int a) {System.out.println(a)}

用lambda表达式，首先看我们的Lambda组成公式：param -> body。有参数就放到()里就行了，那么就是

(int a) -> System.out.println(a)

值得注意的是：

1. 若参数只有一个，则我们可以省略小括号，如下：int a -> System.out.println(a)
2. 我们可以省略参数类型，因为jdk会为我们自动推断。如下：a -> System.out.println(a)

3、多参无返回

方法有一个以上参数且没返回值，比如：

public void test(int a, String b){System.out.println(a + ":" + b)}

用lambda表达式，首先看我们的Lambda组成公式：param -> body。有参数就放到()里就行了，那么就是

(int a, String b) -> {System.out.println(a + ":" + b)}

值得注意的是：

1. 若参数只有一个，则我们可以省略小括号，但是一个以上就不能省略了。int a, String b -> {System.out.println(a + ":" + b)}

2. 我们可以省略参数类型，因为jdk会为我们自动推断。如下：(a, b) -> {System.out.println(a + ":" + b)}

4、多参有返回

方法有一个以上参数且有返回值，比如：

public String test(int a, String b) {return a + ":" + b}

用lambda表达式，首先看我们的Lambda组成公式：param -> body。有参数就放到()里就行了，那么就是

(int a, String b) -> {return a + ":" + b}

值得注意的是：

1. 若参数只有一个，则我们可以省略小括号，但是一个以上就不能省略了。int a, String b -> {return a + ":" + b}
2. 我们可以省略参数类型，因为jdk会为我们自动推断。如下：(a, b) -> {return a + ":" + b}

5、返回体只有一行代码

首先看我们的Lambda组成公式：param -> body。体只有一条的意思是body只有一条语句，这种情况我们可以省略{}，但多条语句的情况则不可省略。另外，单条语句有返回值的情况是可以省略return的。

比如：public void test(int a) {System.out.println(a)} 会写成： a -> System.out.println(a)

比如：public int test(int a) {return a + 100} 会写成： a -> a + 100

总结

普通	lambda写法（最简写法）	备注
public void test() {System.out.println(“hello”)}	() -> System.out.println(“hello”)	非最简写法的方法体可以带花括号。如 () -> {...} 只有一条语句可省略
public void test(int a) {System.out.println(a)}	a -> System.out.println(a)	支持 (int a) -> ... 和 int a -> ... 的写法，只有一个参数可以省略()，也可以省略参数类型
public void test(int a, String b) {System.out.println(a + “:” + b)}	(a, b) -> System.out.println(a + “:” + b)	非一个参数就不能省略 () 了
public String test(int a, String b) {return a + “:” + b}	(a, b) -> a + “:” + b	也可以写成 (a,b)->return a+":"+b，在单条语句的情况下，return可以省略

四、实战演示

1、无参无返回

/**
 * 无参无返回,我们以Runnable接口为例，因为Runnable的run()方法就是无参无返回的。
 */
private static void test1() {
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println("test1");
        }
    };
    runnable.run();
}

public static void main(String[] args) {
    test1();
    /**
     * lambda的方式重写无参无返回。
     * 说明一下：这里的无参无返回指的是Runnable接口的run方法无参无返回，至于细节问题，先不管，下一章节你秒懂。
     * 现在你只需要知道lambda真的很简单！
     */
    Runnable runnable = () -> System.out.println("test1");
    runnable.run();
}

2、一参无返回

/**
 * 一参无返回
 */
private static void test2(int a) {
    System.out.println("a=" + a);
}

public static void main(String[] args) {
    test2(1);
    /**
     * lambda的方式重写一参无返回。
     * 说明一下：这里的无参无返回指的是Consumer接口的accept方法一参无返回，你会问Consumer是什么，先不管，下一章节你秒懂。
     * 现在你只需要知道lambda真的很简单！
     */
    Consumer<Integer> consumer = (a) -> System.out.println("a=" + a);
    consumer.accept(1);
    //---------------------------一参可省略小括号-----------------------------------//
    Consumer<Integer> consumer2 = a -> System.out.println("a=" + a);
    consumer2.accept(1);
}
// 多参无返回同理，用BiConsumer，这里不写了。，直接搞多参有返回吧

3、多参有返回

public static void main(String[] args) {
    /**
     * 多参有返回，这里拿比较接口来做案例
     */
    Comparator<Integer> comparator2 = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            System.out.println("多参有返回");
            return Integer.compare(o1, o2);
        }
    };
    /**
     * lambda的方式重写多参有返回。
     * 说明一下：这里的多参无返回指的是Comparator接口的compare方法多参有返回，细节先不管，下一章节你秒懂。
     * 现在你只需要知道lambda真的很简单！
     */
    Comparator<Integer> comparator = (a, b) -> {
        // 需要注意的是：body多行，{}不能省略。
        System.out.println("多参有返回");
        return a.compareTo(b);
    };
}

五、总结

本章要学会以下东西

• 什么是lambda
• 为什么用lambda
• lambda语法组成
• lambda语法格式
• 并不要求你会用
• 要明白真的节省代码，如下：对接口的创建匿名内部类的实现时，只需一句话，比如：

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

而具体什么样的接口能用lambda呢？我们随便写个interface的话可以用吗？显然不行，这就引人深思了，为什么案例中的Runnable和Comparator接口都可以用lambda替代其内部类的实现？

（应该是只有一个方法的接口才能用lambda，不然编译器怎么知道lambda的代码片段实现接口的哪个方法呢?）