lambda表达式一篇就懂

àì夳堔傛蜴生んèń 2023-06-25 07:51 27阅读 0赞

### 一、概述 ###

本文转载 [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.  若参数只有一个，则我们可以省略小括号，但是一个以上就不能省略了。
> 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.  若参数只有一个，则我们可以省略小括号，但是一个以上就不能省略了。
> 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`

#### 总结 ####

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

### 四、实战演示 ###

##### 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的代码片段实现接口的哪个方法呢?）

[Lambda]: https://www.toutiao.com/i6722634653552869902/?tt_from=weixin&utm_campaign=client_share&wxshare_count=1&timestamp=1577361481&app=news_article&utm_source=weixin&utm_medium=toutiao_ios&req_id=201912261958000101290340322F3317D1&group_id=6722634653552869902