一、Lambda

Lambda表达式，即函数式编程或者匿名函数，Java是从Java8开始支持的，这个概念并不是Java特有的，很多语言（比如JS）都有这个概念，它允许将一系列行为封装后作为参数传递，并可以将其执行一次或多次。便于写出更简洁、灵活、紧凑的代码。

1.Lambda格式

Lambda表达式的基本结构：[函数入参] -> [函数体]
注意：
“->” 是一个整体，中间不能有空格;
函数入参中的参数无需指定参数类型，只有参数名，类型由编译器自动推断；
函数体只有一条语句时可以简写（省略大括号、分号和return）

• 左侧无入参

() -> { /*...*/ }

• 左侧只有一个入参，有两种写法

(a) -> { /*...*/ }
//或者简写为下面的形式（省略圆括号）
a -> { /*...*/ }

• 左侧有多个入参，圆括号不能省略

(a,b) -> { /*...*/ }

• 右侧函数体只有一条语句

//---------------------无返回-------------------
() -> { System.out.println("hello");
}
//可以简写为下面的形式（去掉大括号和语句结尾的分号）
() -> System.out.println("hello")//---------------------带返回-------------------
a -> {return a+1;
}
//可以简写成下面的形式（除了去掉大括号和语句结尾的分号， return 关键字也省略了）
a -> a+1

• 右侧函数体有多条语句

a -> { //函数体的大括号不能省略，分号、return关键字也不能省略int b = 2;return a+b;
}

2.Lambda在Java中的本质

先看看在Lambda出现之前在Java中如何定义一个匿名函数

new Thread(new Runnable() { //这是一个匿名内部类@Overridepublic void run() {//方法实现System.out.println("hello");}
}).start();

Lambda的写法

new Thread(() -> System.out.println("hello")).start();

可以看出Lambda的本质是 匿名内部类
Lambda看似实现了一个方法，实则实现了一个接口
Lambda的定义形式和run方法是一一对应的，run方法没有入参所以lambda的入参是"()"，run方法没有返回，所以lambda也无需return。

3.什么样的匿名内部类可以用Lambda替代？

让我们先来看看Runnable接口的源码

@FunctionalInterface
public interface Runnable {public abstract void run();
}

试想一下Runnable内部定义了多个方法，Runnable的匿名内部类还能用Lambda代替吗？
答案是不可以，因为有多个方法的时候，lambda就不知道和哪一个方法对应了，也无法做类型推断

• 结论

只有定义了一个方法（default方法除外）的接口的匿名内部类都可以简写成Lambda的形式
也就是函数式接口都可以用lambda作为实现

• 其他说明

1.接口中的default方法是为了兼容老接口使用lambda的一种措施，default关键字声明的方法可以在接口中定义好方法的实现
2.@FunctionalInterface是一个声明注解，声明该接口是一个函数式接口（支持Lambda），但是本身不影响Lambda的支持（也就是这个注解可以省略）
3.虽然@FunctionalInterface注解不是必须的，但还是强烈建议添加上这个注解，不仅仅因为这是一个基本的惯例，而是加上这个注解后，编译器会帮我们检查这个接口是不是函数式接口，如果不是就会报编译错误，如下：

4.JDK内置的Lambda常用范式

java.util.function下面定义了一些常用的Lambda范式，为了使这些范式具有通用性，他们都定义成了泛型类

• 一个入参有返回：Function<T,R>

@FunctionalInterface
public interface Function<T, R> {//只有一个入参（类型为T），有返回（类型为R）R apply(T t);//省略其他方法...
}

• 一个入参无返回：Consumer<T>

@FunctionalInterface
public interface Consumer<T> {//只有一个入参（类型是T），无返回void accept(T t);//这就是一个写在接口里的default方法default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}

• 无入参有返回：Supplier<T>

@FunctionalInterface
public interface Supplier<T> {//无入参，有返回（类型为T）T get();
}

• 一个入参返回布尔：Predicate<T>

@FunctionalInterface
public interface Predicate<T> {//只有一个入参（类型为T），有返回（类型为布尔）boolean test(T t);//省略其他方法...
}

Predicate<T> 可以看作是 Function<T,Boolean>

以上的四个范式除了Supplier其他三个还有两个入参的版本，
分别是BiFunction<T, U, R> ， BiConsumer<T, U> 和 BiPredicate<T, U>

5.天然的策略模式

Lambda是天然的策略模式，当我们在某个地方想要一个结果，但是获得结果的具体实现未知或者有多种的时候就可以考虑用函数式接口作为入参让调用方去实现，这种设计在集合流Stream框架中尤为多见。

public static String doSomething(String name, Function<String, String> f){return f.apply(name); //某个人做一些事（什么事不知道，调用的时候再定义）
}
public static void main(String[] args) {System.out.println(doSomething("张三", name -> name + "吃香蕉")); //张三吃香蕉System.out.println(doSomething("张三", name -> name + "吃苹果")); //张三吃苹果
}

一般来说JDK内置的Lambda函数式接口（Function、Consumer、Supplier…）能满足大部分的场景，如果找不到满足需要的范式，可以自己定义函数式接口（定义只有一个方法的接口，加上@FunctionalInterface注解但不是必须）

6.柯里化

柯里化即把一部分变量固化在函数内部，本质就是闭包持有的外部变量
详情见我的另一篇博客： Java柯里化实现

7.Lambda引用的外部变量不可变

在Java中，Lambda表达式内部访问的局部变量必须是final或者事实上的final。这是因为Lambda表达式实际上是一个闭包，它包含了对其外部的变量的引用，而这些变量在Lambda表达式执行期间不能被修改，否则会导致线程安全问题。

public static void main(String[] args) {int count = 0;Runnable r = () -> {count++; // 编译错误，变量count必须被声明为final或者事实上的final};r.run();
}

• 可修改为：

public static void main(String[] args) {AtomicInteger count = new AtomicInteger(0);Runnable r = () -> {count.incrementAndGet(); // 使用AtomicInteger代替int，避免线程安全问题};r.run();System.out.println("count: " + count.get());
}

二、方法引用

方法引用（Method Reference）是Java 8引入的一项重要特性，它提供了一种简洁、可读性高的方式来直接引用已经存在的方法。

简单的说就是在已存在的方法中（静态方法、对象方法或者构造方法），如果一个方法符合某个Lambda范式，那么就可以用这个方法的引用直接替代Lambda表达式。

1.方法引用格式

方法引用的基本形式：[方法归属]::[方法名]
注意：
“::” 是一个整体，中间不能有空格;
方法归属可以是类名、对象名或"this"
在引用构造方法时，方法名为"new"

• 引用静态方法

ClassName::methodName

• 引用构造方法

ClassName::new

• 引用对象方法

objectName::methodName

• 在当前类引用对象方法

this::methodName

2.代码示例

package com.vz.demo.test;import java.util.function.Function;
import java.util.function.Supplier;public class MethodRefTest {public static String eating(String name, Function<String, String> f){return f.apply(name);}public static String test1(){//return eating("张三", name -> name + "吃香蕉");return eating("张三", MethodRefTest::eatBanana); //引用静态方法}public String test2(){//return eating("李四", name -> name + "吃苹果");return eating("李四", this::eatApple); //引用当前对象方法}public static String eatBanana(String name){return name + "吃香蕉";}public String eatApple(String name){return name + "吃苹果";}public String eatOrange(String name){return name + "吃橙子";}public static MethodRefTest getInstance(Supplier<MethodRefTest> supplier){return supplier.get();}public static void main(String[] args) {System.out.println(test1());//MethodRefTest methodRefTest = getInstance(() -> new MethodRefTest());MethodRefTest methodRefTest = getInstance(MethodRefTest::new); //引用无参构造方法System.out.println(methodRefTest.test2());//System.out.println(eating("王五", name -> name + "吃橙子"));System.out.println(eating("王五", methodRefTest::eatOrange));//引用对象方法}
}

• 打印结果：

张三吃香蕉
李四吃苹果
王五吃橙子