Java 8 -- Lambda

迷南。 2022-06-02 10:54 128阅读 0赞

## Lambda 表达式 ##

### 为什么使用 Lambda 表达式 ###

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java 语言的表达能力得到了提升。

从匿名类到 Lambda 的转换

//匿名内部类
    Runnable r1 = new Runnable(){
        @Override
        public void run(){
            System.out.println("Hello World!");
        }
    }

//Lambda 表达式
    Runnable r1 = () -> SSystem.out.println("Hello Lambda!");
    }

//原来使用匿名内部类作为参数传递
    TreeSet<String> ts = new TreeSet<>(new Comparator<String>(){
        @Override
        public int compare(String o1, String o2){
            return Integer.compare(o1.length(), o2.length())；
        }
    });

//Lambda 表达式作为参数传递
    TreeSet<String> ts = new TreeSet<>((o1, o2) -> Integer.compare(o1.length(), o2.length()) );

### Lambda 表达式语法 ###

Lmabda 表达式在 Java 语言中引入了一个新的语法元素和操作符。这个操作符为“->”，该操作符被称为 Lambda 操作符或尽头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的所有参数  
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

语法格式一：无参，无返回值，Lambda 体只需一条语句

Runnable r1 = () -> System.out.println("Hello Lambda!");

语法格式二：Lambda 需要一个参数

Consumer<String> fun = (args) -> System.out.println(args);

语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略

Consumer<String> fun = args -> System.out.println(args);

语法格式四：Lambda 需要两个参数，并且由返回值

BinaryOperator<Long> bo = (x, y) -> {
        System.out.println("实现函数接口的方法！");
        return x + y;

语法格式五：当 Lambda 体只有一条语句时， return 与大括号可以省略

BinaryOperator<Long> bo = (x, y) -> x + y;

语法格式六：

BinaryOperator<Long> bo = (Long x, Long y) -> {
        System.out.println("实现函数接口的方法！");
        return x + y;

数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

#### 类型推断 ####

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断除了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由便编译器推断出来的。这就是所谓的“类型推断”。

## 函数式接口 ##

### 什么是函数式接口 ###

*  只包含一个抽象方法的接口，称为函数式接口。
 *  你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda 表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
 *  我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检测它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

### 自定义函数式接口 ###

@FunctionalInterface
    public interface MyNumber{
        public double getValue();
    }

函数式接口中使用泛型：

@FunctionalInterface
    public interface MyFunc<T>{
        public T getValue(T t);
    }

### 作为参数 传递 Lambda 表达式 ###

public String toUpperString<MyFunc<String> mf, String str){
        return mf.getValue(str);
    }

作为参数传递 Lambda 表达式：

String newStr = toUpperString((str) -> str.toUpperCase(), "abcdef"); System.out.println(newStr);

作为参数 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收 Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口类型。

### Java 内置四大核心函数式接口 ###

<table> 
 <thead> 
  <tr> 
   <th>函数式接口</th> 
   <th>参数类型</th> 
   <th>返回类型</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Consumer&lt;T&gt;</code>消费型接口</td> 
   <td>T</td> 
   <td>void</td> 
   <td>对类型为 T 的对象应用操作，包含方法：<code>void accept(T t)</code>;</td> 
  </tr> 
  <tr> 
   <td><code>Supplier&lt;T&gt;</code>供给型接口</td> 
   <td>无</td> 
   <td>T</td> 
   <td>返回类型为 T 的对象，包含方法：<code>T get()</code>;</td> 
  </tr> 
  <tr> 
   <td><code>Function&lt;T, R&gt;</code>函数型接口</td> 
   <td>T</td> 
   <td>R</td> 
   <td>对类型为 T 的对象应用操作，并返回结果。结果是 R 类型的对象。包含方法：<code>R apply(T t)</code>;</td> 
  </tr> 
  <tr> 
   <td><code>Predicate&lt;T&gt;</code>断定型接口</td> 
   <td>T</td> 
   <td>boolean</td> 
   <td>确定类型为 T 的对象是否满足某约束，并返回 boolean 值。包含方法 <code>boolean test(T t)</code>;</td> 
  </tr> 
 </tbody> 
</table>

## 方法引用与构造器引用 ##

### 方法引用 ###

当要传递给 Lambda 体操作，已经由实现的方法了，可以使用引用！（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）  
方法引用：使用操作符“::”将方法名和对象或类的名字分割开来。如下三种主要使用情况：  
\- 对象::实例方法  
\- 类::静态方法  
\- 类::实例方法

栗如：

(X) -> System.out.println(x);

等同于

System.out::println

栗如：

BinartOperator<Double> bo = (x, y) -> Math.pow(x, y);

等同于

BinartOperator<Double> bo = Math::pow;

栗如：

compare((x, y) -> x.equals(y), "abdcef", "abcdef");

等同于

compare(String::equals, "abc", "abc");