lambda表达式和方法引用

r囧r小猫 2021-10-24 05:46 262阅读 0赞

### 文章目录 ###

*   *  1.函数式接口
     *   *  1.1.定义
         *  1.2.SerializedLambda
     *  2.lambda
     *   *  2.1.概述
         *  2.2.示例如下
     *  3.方法引用
     *   *  3.1.概述
         *  3.2.定义
         *  3.3.示例
         *  3.4.为什么这么定义这么用？

> jdk1.8以后推出了很多的新特性，比如1.default关键字，2.lambda表达式，3.函数式接口，4.方法引用，5.Date Api，stream等。这里面default和Date Api的用法比较容易理解，这里不做更多阐述。今天我们要说的是 lambda表达式，函数式接口，方法引用以及stream这些比较难以理解、困惑的部分。这些的困惑包括：lambda表达式如何使用，以及为什么这么使用。函数式接口如何使用方法引用。以及stream的基本用法。

## 1.函数式接口 ##

### 1.1.定义 ###

一个接口中**有切只有一个抽象方法**，不包括 equals这类在object中已经定义的方，为了明确表示一个接口是函数式接口，**防止别人在接口中添加其他抽象方法**，我们可以给接口定义的时候添加一个添加一个@FunctionalInterface注解。

示例如下：

package com.bsx.test.lambda;
    
    import java.io.Serializable;
    
    @FunctionalInterface
    public interface IGetter<T> extends Serializable { 
        Object get(T source);
    }

### 1.2.SerializedLambda ###

这一部分内容比较多，请参考另一篇文章：[SerializedLambda][]

## 2.lambda ##

### 2.1.概述 ###

λ表达式有三部分组成：1.参数列表，2.箭头（->），3.一个表达式或语句块，其中表达式是指的是一句代码，语句块是用大括号"\{\}"包起来的一系列代码，而λ本身必须是**函数接口才能使用λ表达式**。lambda 语法本质上是一个匿名方法是【语法糖】，由编译器推断并帮助你转换包装为常规代码。说白了lambad表达式就是把函数定义从原来的标准定义方式给简化了，这是因为**编译器可以根据表达式内容来推断入参、出参**。因此使用lambda可**以使用更少的代码来实现相同功能**。

### 2.2.示例如下 ###

// 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 对象,并在控制台打印,不返回任何值(看起来像是返回void) 
    (String s) -> System.out.print(s)
    // 6.循环打印数组
    String[] atp = { "Rafael Nadal", "Novak Djokovic"};  
    List<String> players =  Arrays.asList(atp);  
      
    // 以前的循环方式 
    for (String player : players) {   
         System.out.print(player + "; ");  
    }  
      
    // 使用 lambda 表达式以及函数操作(functional operation) 
    players.forEach((player) -> System.out.print(player + "; "));  
    String[] players = { "Rafael Nadal", "Novak Djokovic};  
       
    // 7.排序
    // 1.使用匿名内部类根据 name 排序 players 
    Arrays.sort(players, new Comparator<String>() {   
        @Override  
        public int compare(String s1, String s2) {   
            return (s1.compareTo(s2));  
        }  
    });
    
    // 2.使用 lambda expression 排序 players 
    Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));  
    Arrays.sort(players, sortByName);  
      
    // 3.也可以采用如下形式: 
    Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));

## 3.方法引用 ##

### 3.1.概述 ###

在学习lambda表达式之后，我们通常使用lambda表达式来创建匿名方法。然而，有时候我们仅仅是调用了一个已存在的方法。如下：

Arrays.sort(stringsArray,(s1,s2)->s1.compareToIgnoreCase(s2));

在Java8中，我们可以直接通过方法引用来**简写**lambda表达式中已经存在的方法。

Arrays.sort(stringsArray, String::compareToIgnoreCase);

这种特性就叫做方法引用(Method Reference)。

### 3.2.定义 ###

**方法引用**是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种**引用而不执行方法的方式**，它需要由**兼容的函数式接口构成的目标类型上下文**。计算时，**方法引用会创建函数式接口的一个实例**。

当Lambda表达式中只是**执行一个方法调用时**，不用Lambda表达式，直接**通过方法引用的形式可读性更高一些**。方法引用是一种更简洁易懂的Lambda表达式。

注意方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号"::"

### 3.3.示例 ###

首先定义一个包含了各种类型方法的类：

package com.bsx.test.lambda;
    
    /** * @Description: 定义一个包含了各种类型方法的类 * @author: ztd * @date 2019/8/19 上午11:30 */
    public class DoubleColon { 
        public static void printStr(String str) { 
            System.out.println("printStr : " + str);
        }
    
        public void toUpper() { 
            System.out.println("toUpper: " + this.toString());
        }
    
        public void toLower(String str) { 
            System.out.println("toLower: " + str);
        }
    
        public int toInt(String str) { 
            System.out.println("toInt: " + str);
            return 1;
        }
    
        public void printInteger(Integer i) { 
            System.out.println("printInteger: " + i);
        }
    }

写一个测试类

package com.bsx.test.lambdatest;
    
    import com.bsx.test.entity.Person;
    import com.bsx.test.lambda.DoubleColon;
    import org.junit.Test;
    
    import java.util.function.BiConsumer;
    import java.util.function.BiFunction;
    import java.util.function.Consumer;
    
    /** * @Description: * @author: ztd * @date 2019/8/19 上午11:37 */
    public class DoubleColonTest { 
        @Test
        public void testColon() { 
            // =========静态方法==========
            // 静态方法因为jvm已有对象，直接接收入参。
            Consumer<String> printStrConsumer = DoubleColon::printStr;
            printStrConsumer.accept("printStrConsumer");
    
            // =========非静态方法==========
    
            // 方法参数个数=函数式接口参数个数，通过【new 类的实例::方法名】引用
            // 使用的时候，直接传入需要的参数即可
            Consumer<Integer> toPrintConsumer = new DoubleColon()::printInteger;
            toPrintConsumer.accept(123);
    
            // 方法参数个数=函数式接口参数个数-1，通过【类的实例::方法名】引用
            // 使用的时候，传入的第一个参数是类的实例，后面是方法的参数
            Consumer<DoubleColon> toUpperConsumer = DoubleColon::toUpper;
            toUpperConsumer.accept(new DoubleColon());
    
            BiConsumer<DoubleColon, String> toLowerConsumer = DoubleColon::toLower;
            DoubleColon doubleColon = new DoubleColon();
            toLowerConsumer.accept(doubleColon, "toLowerConsumer");
    
            BiFunction<DoubleColon, String, Integer> toIntFunction = DoubleColon::toInt;
            int i = toIntFunction.apply(new DoubleColon(), "toInt");
            System.out.println(i);
        }
    }

你已经看到测试类里面针对不**同类型的方法，方法引用的定义方式并不一样**，使用**方式也不一样**，我们的困惑就在于为什么要这么定义，为什么这么使用？这样我们才能在使用jdk1.8里面的各种Function和stream的时候变得随心所欲。

### 3.4.为什么这么定义这么用？ ###

> 首先我们需要明确的一点是，函数式接口也是接口，只是它里面只有一个抽象方法，在使用的时候跟其他的接口并没有本质区别，区别只在于使用的方式更简洁。要实现它同样需要按照普通接口的规范去使用，比如要保证实现方法和接口的输入输出参数完全对应。

3.4.1.静态方法引用

这个很容易理解，静态方法因为jvm已有对象，直接接收入参函数的定义跟接口完全一致。

// 定义
     public static void printStr(String str) { 
            System.out.println("printStr : " + str);
     }
     // 使用
     Consumer<String> printStrConsumer = DoubleColon::printStr;
     printStrConsumer.accept("printStrConsumer");

3.4.2.非静态方法

// 函数定义
     public void printInteger(Integer i) { 
         System.out.println("printInteger: " + i);
     } 
     public void toUpper() { 
         System.out.println("toUpper: " + this.toString());
     }
     
     // 函数使用
     Consumer<Integer> toPrintConsumer = new DoubleColon()::printInteger;
     toPrintConsumer.accept(123);
     Consumer<DoubleColon> toUpperConsumer = DoubleColon::toUpper;
     toUpperConsumer.accept(new DoubleColon());

非静态方法的函数引用定义和使用就有点让人很困惑了，明明函数式接口里面是2参数，可是非静态方法里面是1个参数，这个是怎么实现的呢？

其实这个不一致是有要求的，就是函数式接口的参数个数-非静态方法参数个数=0或者1，我这里叫它为**参数差**，这个参数差取值范围不能变，如果大于1或者小于0都会报错。

接下来我们分别来讨论0和1的情况。

参数差=0：方法参数个数相等，那么直接通过一个类的实例来调用这个方法即可，因此方法引用就是【**实例::方法名**】，使用的时候也是直接传递所需要的参数即可。

参数差=1：说明非静态方法少一个参数，这是就不能保证接口参数和实现方法参一一对应了，这很明显有问题。这时候我们通过【**类::方法名**】来定义（这种定义方式也是jdk的规定，记住就好）。因为这个方法不是静态方法，定义的时候也没有给它传递类的实例，所以我们需要在使用的时候给这个方法传递一个宿主（类的实例），这个**宿主永远是接口的第一个参数**，我成为**宿主优先原则**，因此就会出现下面的这种定义和使用的方式：

// 方法DoubleColon::toUpper没有参数，因此Consumer的参数就是DoubleColon的一个实例
     // 因此定义的时候Consumer的泛型类型就是DoubleColon
     // 使用的时候只需要传递一个DoubleColon的实例即可
     Consumer<DoubleColon> toUpperConsumer = DoubleColon::toUpper;
     toUpperConsumer.accept(new DoubleColon());

一旦我们知道了**参数差=0或1、宿主优先原则**之后，我们就能够理解jdk1.8以后的各种Function，stream的使用方式为什么是这样那样了。

[SerializedLambda]: https://blog.csdn.net/tengdazhang770960436/article/details/99960693