Java 8（二）：Lambda 表达式

迈不过友情╰ 2021-12-10 13:04 181阅读 0赞

### 文章目录 ###

*   *  1、认识Lambda表达式
     *   *  1.1、Lambda表达式语法
         *  1.2、Lambda 表达式示例
     *  2、函数式接口（Functional interfaces）
     *   *  2.1、Predicate
         *  2.2、Consumer
         *  2.3、Function
     *  3、类型检查
     *  4、类型推断
     *  5、变量作用域
     *   *  5.1、Lambda使用局部变量的限制
         *  5.2、为什么对局部变量限制
     *  6、方法引用
     *   *  6.1、如何构建方法引用
         *  6.2、Lambda构造函数引用
     *  7、复合Lambda表达式

## 1、认识Lambda表达式 ##

Lambda 表达式可以理解为一种匿名函数，它没有名称，但它有参数列表、方法主体、返回类型等

### 1.1、Lambda表达式语法 ###

lambda 表达式的语法格式如下：

(parameters) -> expression
    或
    (parameters) ->{ statements; }

![在这里插入图片描述][20190630165005225.png]

lambda 表达式的语法由参数列表、箭头符号 -> 和函数体组成。函数体既可以是一个表达式，也可以是一个语句块：

**表达式：** 表达式会被执行然后返回执行结果。

**语句块：** 语句块中的语句会被依次执行，就像方法中的语句一样

*  return 语句会把控制权交给匿名方法的调用者
 *  break 和 continue 只能在循环中使用
 *  如果函数体有返回值，那么函数体内部的每一条路径都必须返回值

**表达式函数体** 适合小型 lambda 表达式，它消除了 return 关键字，使得语法更加简洁。

以下是lambda表达式的重要特征:

**可选类型声明：** 不需要声明参数类型，编译器可以统一识别参数值。

**可选的参数圆括号：** 一个参数无需定义圆括号，但多个参数需要定义圆括号。

**可选的大括号：** 如果主体包含了一个语句，就不需要使用大括号。

**可选的返回关键字：** 如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

### 1.2、Lambda 表达式示例 ###

// 1. 不需要参数,返回值为 5  
    () -> 5  
      
    // 2. 接收一个参数(数字类型),返回其2倍的值  
    x -> 2 * x  
      
    // 3. 接受2个参数(数字),并返回他们的差值  
    (x, y) -> x – y  
      
    // 4. 接收2个int型整数,返回他们的和  
    (int x, int y) -> x + y  
      
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值 
    (String s) -> System.out.print(s)

## 2、函数式接口（Functional interfaces） ##

在哪里可以使用lambda表达式呢？答案是：在函数式接口上使用lambda表达式。是否还记得在上一节 [Java 8（一）：行为参数化][Java 8]中的示例吗？其中 Predicate 接口就是一个函数式接口，因为 Predicate 仅仅定义了一个抽象方法：

interface Predicate<T>{
 boolean test(T t);
 }

***函数式接口：*** 就是只定义了一个抽象方法的接口。例如，Java API 中的Comparator,Runnable,Callable 等。

Java SE 7 中已经存在的函数式接口：

*  [java.lang.Runnable][]
 *  [java.util.concurrent.Callable][]
 *  [java.security.PrivilegedAction][]
 *  [java.util.Comparator][]
 *  [java.io.FileFilter][]
 *  [java.beans.PropertyChangeListener][]

Java SE 8中增加了一个新的包：java.util.function，它里面包含了常用的函数式接口：

* Predicate——接收 T 并返回 boolean
 * Consumer——接收 T，不返回值
 * Function<T, R>——接收 T，返回 R
 * Supplier——提供 T 对象（例如工厂），不接收值
 * UnaryOperator——接收 T 对象，返回 T
 * BinaryOperator——接收两个 T，返回 T

### 2.1、Predicate ###

java.util.function.Predicate接口定义了一个名叫test的抽象方法，它接受一个泛型T对象，并返回一个boolean

@FunctionalInterface
 public interface Predicate<T> {
 boolean test(T t);
 }

使用示例如下：

public static void main(String[] args) {
 //非空字符串判断，lambda表达式
 Predicate<String> nonEmptyStringPredicate = s -> !s.isEmpty();
 //过滤非空字符串，lambda表达式作为参数传递
 List<String> nonEmptyStringLis = filter(Arrays.asList("hello", "world", ""), nonEmptyStringPredicate);
 System.out.println(nonEmptyStringLis);
 }
 
 public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
 List<T> results = new ArrayList<>();
 for (T s : list) {
 if (predicate.test(s)) {
 results.add(s);
 }
 }
 return results;
 }

### 2.2、Consumer ###

java.util.function.Consumer定义了一个叫accept的抽象方法，它接受一个泛型T的对象，并没有返回（void）

@FunctionalInterface
 public interface Consumer<T> {
 void accept(T t);
 }

使用示例：

/**
 * java.util.function.Consumer<T>定义了一个叫accept的抽象方法，它接受一个泛型T的对象，并没有返回（void）
 */
 public class ConsumerDemo {
 public static void main(String[] args) {
 //遍历对象集合，并打印每一个元素
 forEach(Arrays.asList(2, 4, 9), System.out::println);
 }
 
 /**
 * 根据 consumer 遍历对象
 */
 public static <T> void forEach(List<T> list, Consumer<T> consumer) {
 for (T t : list) {
 consumer.accept(t);
 }
 }
 }

### 2.3、Function ###

java.util.function.Function<T, R>定义了一个叫apply的抽象方法，它接受一个泛型T的对象，并返回一个泛型R对象

@FunctionalInterface
 public interface Function<T, R> {
 R apply(T t);
 }

使用示例：

/**
 * java.util.function.Function<T, R>定义了一个叫apply的抽象方法，它接受一个泛型T的对象，并返回一个泛型R对象
 */
 public class FunctionDemo {
 public static void main(String[] args) {
 //计算集合中的每一个元素的长度
 List<Integer> strLength = map(Arrays.asList("hello,world", "lambda"), s -> s.length());
 System.out.println(strLength);
 
 }
 
 /**
 * 遍历 list 并转换每一个元素，返回转换后的集合
 *
 * @param list 被操作对象集合
 * @param function 转换表达式
 */
 public static <T, R> List<R> map(List<T> list, Function<T, R> function) {
 List<R> result = new ArrayList<>();
 for (T t : list) {
 result.add(function.apply(t));
 }
 return result;
 }
 }

## 3、类型检查 ##

Lambda 的类型是从Lambda 的上下文推断出来的。上下文中Lambda表达式需要的类型称为\*\*\*目标类型\*\*\*。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]

## 4、类型推断 ##

还可以进一步简化代码。java编译器会从上下文（目标类型）推断出用什么函数式接口来配合Lambda表达式，这意味着它也可以推断出适合Lambda的签名，因为函数描述符可以通过目标类型来获取。这样就可以在Lambda语法中省去参数类型的声明。

//需要类型推断，仅有一个参数需要类型推断时，参数两边的括号可以省略
 List<Apple> greenApple = appleList.stream().filter(a -> a.getColor().equals("green")).collect(Collectors.toList());
 //需要类型推断
 Comparator<Apple> apple1 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
 //不需要类型推断
 Comparator<Apple> apple2 = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

## 5、变量作用域 ##

Lamdba 可以没有限制的使用实例变量和静态变量。但是局部变量必须显示声明为final或者事实上是final（即一个变量虽然没被final修饰，但是他在后面也没被修改）。

下面的代码将会编译错误，因为portNumber变量被赋值了两次

int portNumber = 1337;
    Runnable r = () -> System.out.println(portNumber);
    //编译错误
    portNumber = 31337;

### 5.1、Lambda使用局部变量的限制 ###

Lambda表达式对值封闭，不是对变量封闭。Lambda表达式引用的局部变量必须是final的，只能有一次赋值。

### 5.2、为什么对局部变量限制 ###

实例变量是储存在堆中，而局部变量是储存在栈上。如果Lambda可以直接访问局部变量，而Lambda是在一个线程中使用的，则使用Lambda的线程可能会在分配该变量的线程将这个变量收回之后，去访问该变量。因此，Java在访问自由局部变量时，实际上是在访问他的副本而不是访问原始变量。

## 6、方法引用 ##

方法引用就是Lambda的快捷写法。目标引用放在分隔符::前面，方法的名称放在后面。例如，Apple::getWeight 就是引用了Apple类中一个的getWeight方法。这里时不需要括号的，因为并没有实际调用该方法。

使用方法引用之前：

Comparator<Apple> apple2 = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

使用方法引用之后：

Comparator<Apple> apple3 = Comparator.comparing(Apple::getWeight);

Lambda表达式及其等价方法引用：

<table> 
 <tbody> 
 <tr> 
 <td>Lambda表达式</td> 
 <td>等效的方法引用</td> 
 </tr> 
 <tr> 
 <td>(Apple a) -&gt; a.getWeight()</td> 
 <td>Apple::getWeight</td> 
 </tr> 
 <tr> 
 <td>() -&gt;&nbsp;Thread.currentThread().dumpStack()</td> 
 <td>Thread.currentThread()::dumpStack</td> 
 </tr> 
 <tr> 
 <td>(str, i) -&gt; str.substring(i)</td> 
 <td>String::substring</td> 
 </tr> 
 <tr> 
 <td>(String s) -&gt; System.out.println(s)</td> 
 <td>System.out::println</td> 
 </tr> 
 </tbody> 
</table>

### 6.1、如何构建方法引用 ###

方法引用主要有三类:

（1）指向静态方法的方法引用

例如：Integer 的 parseInt 方法，等价于 Integer::parseInt

（2）指向任意类型实例方法的引用

例如：String 的 length 方法，等价于 String::length

（3）指向现有对象的实例方法的引用

例如：局部变量 apple 用来存放 Apple 类型的对象，它的实例方法是 getWeight，那么方法引用就可以这样写：apple::getWeight

### 6.2、Lambda构造函数引用 ###

对于一个现有构造函数，可以利用它的名称和关键字new来创建它的一个引用：ClassName::new。它的功能与静态方法的引用类似。

<table> 
 <tbody> 
 <tr> 
 <td>Lambda表达式</td> 
 <td>等价构造函数引用Lambda表达式</td> 
 </tr> 
 <tr> 
 <td>Supplier&lt;Apple&gt; c1 = Apple::new;Apple a1 = c1.get();</td> 
 <td>Supplier&lt;Apple&gt; c1 = () -&gt; new Apple();Apple a1 = c1.get();</td> 
 </tr> 
 <tr> 
 <td>Function&lt;Integer, Apple&gt; c2 = Apple::new;Apple a2 = c2.apply(110);</td> 
 <td>Function&lt;Integer, Apple&gt; c2 = (weight) -&gt; new Apple(weight);Apple a2 = c2.apply(110);</td> 
 </tr> 
 <tr> 
 <td>BiFunction&lt;String, Integer, Apple&gt; c2 = Apple::new;Apple a2 = c2.apply("green", 110);</td> 
 <td>BiFunction&lt;String, Integer, Apple&gt; c2 = (color, weight) -&gt; new Apple(color, weight);Apple a2 = c2.apply("green", 110);</td> 
 </tr> 
 </tbody> 
</table>

## 7、复合Lambda表达式 ##

把多个简单的Lambda表达式复合成复杂的表达式，可以让两个谓词or操作，组成一个更大的谓词，可以让一个函数的结果成为另一个函数的输入参数。

<table> 
 <tbody> 
 <tr> 
 <td>复合类型</td> 
 <td>方法</td> 
 <td>说明</td> 
 <td>举例</td> 
 </tr> 
 <tr> 
 <td>比较器复合</td> 
 <td>reversed()</td> 
 <td>逆序</td> 
 <td>//按重量递减排序inventory.sort(comparing(Apple::getWeight)).reversed();</td> 
 </tr> 
 <tr> 
 <td>thenComparing</td> 
 <td>比较器链（接受一个函数作为参数，如果两个对象用第一个Comparator比较之后是一样的，就提供第二个Comparator</td> 
 <td>//两个苹果一样重时按国家排序inventory.sort(comparing(Apple::getWeight)).reversed().thenComparing(Apple::getCountry);</td> 
 </tr> 
 <tr> 
 <td>谓词复合（and和or方法的优先级是按照在表达式链中的位置，从左向右确定的）</td> 
 <td>negate</td> 
 <td>非</td> 
 <td>//产生现有对象redApple的非Predicate&lt;Apple&gt; notRedApple = redApple.negate();</td> 
 </tr> 
 <tr> 
 <td>and</td> 
 <td>将两个Lambda用and组合起来</td> 
 <td>//一个苹果既是红色又比较重（链接两个谓词来生成一个Predicate对象）Predicate&lt;Apple&gt; RedAndHeavyApple = redApple.and(a -&gt; a.getWeight() &gt; 150);</td> 
 </tr> 
 <tr> 
 <td>or</td> 
 <td>要么</td> 
 <td>//要么重(150g以上)的红苹果，要么是绿苹果Predicate&lt;Apple&gt; RedAndHeavyApple = redApple.and(a -&gt; a.getWeight() &gt; 150)&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;.or(a -&gt; "green".equals(a.getColor()));</td> 
 </tr> 
 <tr> 
 <td>函数复合</td> 
 <td>andThen</td> 
 <td>先对输入应用一个给定函数，再对输出应用另一个函数</td> 
 <td>//等同于数学上的g(f(x))，返回4Function&lt;Integer, Integer&gt; f = x -&gt; x + 1;Function&lt;Integer, Integer&gt; g = x -&gt; x * 2;Function&lt;Integer, Integer&gt; h = f.andThen(g);int result = h.apply(1);</td> 
 </tr> 
 <tr> 
 <td>compose</td> 
 <td>先把给定的函数用作compose的参数里面给的那个函数，然后再把函数本身用于结果</td> 
 <td>//等同于数学上的f(g(x))，返回3Function&lt;Integer, Integer&gt; f = x -&gt; x + 1;Function&lt;Integer, Integer&gt; g = x -&gt; x * 2;Function&lt;Integer, Integer&gt; h = f.compose(g);int result = h.apply(1);</td> 
 </tr> 
 </tbody> 
</table>

[20190630165005225.png]: /images/20211210/899862084fe345a080da31b4378f3905.png
[Java 8]: https://blog.csdn.net/u010647035/article/details/94329361
[java.lang.Runnable]: http://download.oracle.com/javase/7/docs/api/java/lang/Runnable.html
[java.util.concurrent.Callable]: http://download.oracle.com/javase/7/docs/api/java/util/concurrent/Callable.html
[java.security.PrivilegedAction]: http://download.oracle.com/javase/7/docs/api/java/security/PrivilegedAction.html
[java.util.Comparator]: http://download.oracle.com/javase/7/docs/api/java/util/Comparator.html
[java.io.FileFilter]: http://download.oracle.com/javase/7/docs/api/java/io/FileFilter.html
[java.beans.PropertyChangeListener]: http://www.fxfrog.com/docs_www/api/java/beans/PropertyChangeListener.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]: /images/20211210/ef3774cf95e7429f940fafc5207a38c6.png