Java JDK1.8 核心特性详解------Lambda表达式与方法引用

傷城~ 2022-03-22 13:48 214阅读 0赞

在上一篇文章中，我们介绍了行为参数化（[Java JDK1.8 核心特性详解------行为参数化][Java JDK1.8 _------]），并且简单展示了Lambda表达式给我们带来的好处。今天这篇文章将会介绍如何构建Lambda，它的使用场合，以及如何利用它使代码更加简洁。

--------------------

# Lambda表达式与方法引用 #

## Lambda表达式介绍 ##

Lambda表达式可以理解为**简洁地表示可传递匿名函数的一种简单方式**：没有名称，但是有参数列表，函数主体，返回类型，可能还有可抛出的异常。

*  匿名：它不像普通的方法一样有一个具体的名称，比较像匿名类
 *  函数：Lambda不像方法一样属于某个特定的类，但和方法一样，有参数列表、函数主体、返回类型以及异常
 *  传递：Lambda表达式可以作为参数传递给方法或者储存在变量中
 *  简洁：不用像匿名类那样写很多模版代码

在上一篇的最后一部分代码中，你可以发现匿名函数被下面代码取代，而这个就是Lambda表达式。

(People people)-> "男".equals(people.getName())

Lambda表达式由参数列表**（People people）**,箭头  **->** 、和Lambda主体 ** "男".equals(people.getName())** 三部分组成。

参数列表就是方法需要传入的参数，其写法有以下不同几种

//完整的参数列表
    (People people)-> "男".equals(people.getName())
    //参数类型可以省略
    （people） -> "男".equals(people.getName())
    //当传入参数只有一个时，括号可以省略
    people -> "男".equals(people.getName())
    //当传入多个参数，或者不传参数时，括号不能省略
    (People people,People  people1) -> people.getName.equals(people1.getName())
    //当传入多个参数，或者不传参数时，括号不能省略，多个参数的参数类型也可以省略
    (people, people1) -> people.getName.equals(people1.getName())

箭头（**->**）用来分隔参数列表和方法主体。

主体中的表达式是方法的主要功能。其写法有以下两种

//当没有花括号时，表达式结果就是返回值,隐含了return，
    （people） -> "男".equals(people.getName())
    //当有花括号时，要显性返回方法要求的返回信息
    （people） -> {return "男".equals(people.getName())}

## 在哪里使用Lambda表达式 ##

Lambda表达式可以用来替换**函数式接口的实现类**。例如上面用Lambda表示式，避免了定义新的类或者使用匿名函数。那什么是函数式接口呢？

**函数式接口**是指接口里面只定义了**一个抽象方法**，换句话说，函数式接口就是只定义了**一个抽象方法的接口**。（上篇文章中的FilterPeople 接口就是一个函数式接口）

//这个是函数式接口，因为只定义了一个抽象方法
    public interfaceFunctionalInterface1 {
        int functional();
    }
    
    //这个不是函数式接口，因为里面定义了两个抽象方法
    public interfaceNotFunctionalInterface2 {
        int functional();
    
        int functional2();
    }
    
    //这个也是函数式接口，因为里面只定义了一个抽象方法
    public interface FunctionalInterface3 {
        int functional();
        //functional2是默认方法，后面的文章会提到，这里你就把他当作普通的方法。
        default int functional2() {
            return 1;
        }
    }

在Java8中，新增了一个注解@FunctionalInterface，这个注解使用来接口上，用来声明这是一个函数式接口，如果有这个注解的接口内，存在一个以上的抽象方法，在编译的时候就会报错。 类似@Override，标注方法被重写了，如果没有上级没有这个方法，就会报错。

函数式接口的抽象方法的签名基本上就是Lambda表达式的签名，我们经常使用**函数描述符**来描述Lambda表达式和函数式接口的签名。例如interfaceFunctionalInterface1 接口中的functional方法，它可以用（）->int来表示。（）->int表示传入参数为空，返回值为int。又如前一章FilterPeople接口，也是一个函数式接口，我们用（People，People）->boolean，来表示boolean test(People people)这个方法，这表明传入两个People类型的参数，然后方法返回一个boolean值。又例如Runnable的函数描述符是（）->void，这表示run这个方法的传入值为空，返回值为void；

## 如何使用Lambda表达式 ##

Lambda表达式不是随时随地都可以使用的，一般来说，我们是用在某些传入参数是某些函数式接口（或者函数式接口子类，但是调用了函数式接口内的方法）的地方，它可以用来代替一些匿名类。或者是赋给一个变量。最常见地方就是策略设计模式，模版方法，观察者模式，责任链模式以及工厂模式。我们会演示策略设计模式时如何使用Lambda：

例如我们需要完成一个将int类型的值按照一定的业务转成String类型的值，方法接口设计如下：

public static String castIntToString(int i, Function a) {
            return a.cast(i);
        }

通过传入不同的Function策略来对i进行转化。这里的Function是一个函数式接口。具体代码如下：

@FunctionalInterface
    public interface CastFunction {
    
        String castClass(int r);
    }

当我们要求将传入的int按不同业务逻辑转化为String的时候，我们以前可能会这么写：

//直接转为String
            String string = castIntToString(1, new CastFunction () {
                @Override
                public String cast(int r) {
                    return r + "";
                }
            });
            //将int值乘2以后返回
            String string1 = castIntToString(1, new CastFunction () {
                @Override
                public String cast(int r) {
                    return r*2 + "";
                }
            });

但是，如果我们通过Lambda表达式，方法就会简单很多。首先我们先转化它的抽象方法，(int)->String。结合上面的讲的Lambda的组成，那么我们可以这样写 :

//直接转为String
            String string = castIntToString(1, r -> r + "");
            //将int值乘2以后返回
            String string1 = castIntToString(1, r -> r*2 + "");

你会发现代码一下子简单了很多。在这里，你可能会觉得这个代码比较难理解，因为这里隐藏了实现的接口名，以及实现的抽象方法。但是当你熟练使用Lambda以后，你会觉得这样很酷。

Java8给我们提供了部分常用的函数式接口,让我们可以直接使用

<table> 
 <tbody> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">使用案例&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">函数描述符</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">对应的函数式接口&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">功能要求</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">Lambda 的例子&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">布尔表达式</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">T -&gt;boolean</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">Predicate&lt;T&gt;&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">判断List&lt;String&gt;数量是否为空</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">List&lt;String&gt; list -&gt; list.isEmpty()</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">创建对象&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">()-&gt;T</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">Supplier&lt;T&gt;&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">创建一个People</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">() -&gt; new People</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">消费一个对象&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">T-&gt;void</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">Consumer&lt;T&gt;</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">打印People的年龄</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">(People p)-&gt;System.out.print(p.getAge)</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">传入一个对象返回另一种类型对象&nbsp;</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">T-&gt;R</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">Function&lt;T, R&gt;</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">将int转为String</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">(int i) -&gt; i+""</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">合并两个值</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">(T,U)-&gt;R</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">IntBinaryOperator</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">返回两个值的乘积</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">(int a, int b) -&gt; a * b&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="text-align:left;vertical-align:middle;width:154px;">比较两个对象</td> 
   <td style="text-align:left;vertical-align:middle;width:154px;">(T,T)-&gt;boolean</td> 
   <td style="text-align:left;vertical-align:middle;width:167px;"> <p>Comparator&lt;T&gt;或</p> <p>BiFunction&lt;T, T, R&gt;<br> 或&nbsp;ToIntBiFunction&lt;T, T&gt;&nbsp;</p> </td> 
   <td style="text-align:left;vertical-align:middle;width:167px;">比较两个People谁年龄大</td> 
   <td style="text-align:left;vertical-align:middle;width:304px;">(People p1, People p2) -&gt;&nbsp;p1.getAge().compareTo(p2.getAge())</td> 
  </tr> 
 </tbody> 
</table>

**注：由于JDK1.8中接口支持默认方法，但即使一个接口中有很多默认方法，只要接口只定义了一个抽象方法，它就仍然是一个函数式接口。**

## 类型检查、类型推断和限制 ##

**类型检查**

Lambda 表达式本身并不包含它是实现哪个函数式接口的信息，编译器会根据 Lambda 表达式所处的上下文（context）环境来推断 Lambda 表达式的**目标类型**（target type），例如对于下面的代码：

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

Lambda 表达式会赋值给 Runnable 对象，那么该 Lambda 表达式对应的**目标类型**就是 Runnable 接口，该接口中的 a方法对应的函数描述符为 `() -> void`，这个和 `()->System.out.println("Runnable")` 可以匹配，这样就完成了类型检查。下图是一个完整的例子，概述了代码的类型检查过程，这个是《Java8实战》上的一个例子，用来筛选苹果集合中重量大于150g的苹果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW56ejI1NjA_size_16_color_FFFFFF_t_70][]

有了目标类型的接口，因此，只要函数签名相同，Lambda就可以混合使用。例如Callable接口和PrivilegedActionj接口的都是函数式接口，函数描述都是（）->T，代表什么都不接受并返回一个泛型T的实例。那么，下面两个赋值都是有效的：

Callable<String> callable = () -> "a";
            PrivilegedAction<String> privilegedAction = () -> "a";

第一个Lambda的赋值的**目标类型**是Callable<String>，第二个幅值的**目标类型**是PrivilegedAction<String>。

特殊的void兼容规则
        如果一个Lambda的主体是一个语句表达式，他就和一个返回void的函数描述符兼容（当然需要参数列表也兼容）。例如，以下两行都是合法的，尽管List的add方法返回的是一个boolean，而不是Consumer上下文（T->void）所要求的viod：
            //Predicate返回一个boolean
            Predicate<People> p = people -> peopleList.add(new People("张三", 10));
            //Consumer返回一个void
            Consumer<People> a = people ->  peopleList.add(new People("张三", 10));

**类型推断**

正如我之前说的，我们在写Lambda表达式的时候可以省略参数类型。这是因为Java编译器会从上下文自动帮我们推断出用什么函数式接口。有时候显式写出参数类型有助于提高代码可读性，有时候省略有助于代码可读性，具体要你自己选择。

**使用局部变量**

我们之前Lambda表达式中用的都是参数列表中传入的变量，但是Lambda表达式还允许使用自由变量（不是参数，而是在外层作用域中定义的变量）。它们被称为捕捉Lambda。例如，下面Lambda捕捉了number变量：

int number = 1;
            Runnable runnable = () -> System.out.println(number);

**Lambda表达式可以没有限制的实例变量 和静态变量，但是使用局部变量时，必须显式申明为final或者实际上是final。**实例变量和静态变量好理解，局部变量？下面举个例子：

final unmber = 1;
            Runnable runnable = () -> System.out.println(number);//这里编译器不会报错
    
            unmber2 = 1;
            Runnable runnable = () -> System.out.println(number2);//这里编译器不会报错
    
            int number3 = 1;
            numbe3r=3;
            Runnable runnable = () -> System.out.println(number3);//这里编译器会报错
            
            unmber4 = 1;
            Runnable runnable = () -> {
                number4 = number4+1;
                System.out.println(number4);//这里编译器会报错
            };

对于局部变量，我们要想在Lambda中使用，必须对这个变量必须是final或者是effectively final。第二个例子中，number2在赋值过后没有再次修改，JDK1.8就在前面默认他是effectively final的。

为什么会这么要求呢？个人理解是，因为实例变量和静态变量是保存在堆中，局部变量是保存在栈里，当Lambda在一个线程运行时，想要访问自由变量（局部变量），可能会出现局部变量已经被销毁了。所以，为了保证Lambda可以访问到这个自由变量，Lambda访问的是这个自由变量的副本，即便以前的变量销毁了，Lambda还是可以通过这个副本正常访问到以前的值。如果这个副本不是final或者effectively final，可能会导致安全问题。

## **方法引用** ##

方法引用可以被看做仅仅调用特定方法的**Lambda表达式的简单写法**（如果一个Lambda主体只是调用这个方法（**主体没有｛｝**），就可以用方法引用来替代这个Lambda表达式），方法引用可以重复使用现有的方法定义，并像Lambda一样传递他们，同时更加简洁。例如下面这两行代码是等效的：

FilterPeople filterPeople = (People people) -> people.getName();
    
    FilterPeople filterPeople = People::getName;

那要如何使用它呢？

**目标引用**放在分隔符**：：**前，**方法的名称**放在后面**。**例如People::getName代表引用People类中的getName方法，这是上面Lambda表达式的快捷写法。

方法引用可以看做单一方法的Lambda的语法糖，主要有三类：

（1）指向静态方法的方法引用，例如方法主体是调用Integer的parseInt方法**（String s）->Integer.parseInt(s) ** 可以用**Integer：：parseInt** 来代替

Function<String, Integer> stringIntegerFunction0 = (String string) -> Integer.parseInt(string);
    Function<String, Integer> stringIntegerFunction1 = Integer::parseInt;

（2）指向任意类型实例方法的方法引用，例如方法主体是调用String的length方法**（String s）->s.length() ** 可以用  ** String：：length **来代替。

Function<String, Integer> stringIntegerFunction = (String string) -> string.length();
    Function<String, Integer> stringIntegerFunction1 = String::length;

（3）指向现有对象的实例方法的方法引用，例如方法主体是调用People的getName方法，写作People::getName。

//people是自由变量
    Runnable runnable = () -> people.getName();
    Runnable runnable1 = People::getName;

## 构造函数引用 ##

对于一个现有构造函数，你可以利用它的名称和关键字new来创建它的一个引用。例如之前我们提到Supplier<Apple> 函数式接口可以用来创建对象实例。例如：

Supplier<People> peopleFunction = () -> new People();
            People people = peopleFunction.get();

通过构造函数引用，可以将代码写作：

Supplier<People> peopleFunction = People::new;
            People people = peopleFunction.get();

对于多参构造器，Java8提供了很多多参的函数式接口，让我们也可以用构造引用来创建。

到目前为止，Lambda表达式的内容基本结束了，事实上，Lambda更适合和JDK提供Stream配合使用。下面一部分将会介绍流的使用方式，以及如何和Lambda组合使用。

--------------------

更多与JDK1.8相关的文章请看：[Java JDK1.8 核心特性详解----(总目录篇)][Java JDK1.8 _----]

[Java JDK1.8 _------]: https://blog.csdn.net/chenzz2560/article/details/86670590
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW56ejI1NjA_size_16_color_FFFFFF_t_70]: /images/20220322/94b8726de1064754bf002abe5235122e.png
[Java JDK1.8 _----]: https://blog.csdn.net/chenzz2560/article/details/86671293