Java Lambda和方法引用

一、Lambda

Lambda表达式，即函数式编程或者匿名函数，是从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() { //这是一个匿名内部类
    @Override
    public 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注解不是必须的，但还是强烈建议添加上这个注解，因为加上这个注解后，编译器会帮我们检查这个接口是不是函数式接口，如果不是就会报编译错误，如下：

@FunctionalInterface源码有以下注释：

If a type is annotated with this annotation type, compilers are required to generate an error message unless:
如果一个类标注了该注解，则编译器可能会生成错误消息，除非：

• The type is an interface type and not an annotation type, enum, or class.
  类型是接口，而不是注解、枚举或类。
• The annotated type satisfies the requirements of a functional interface.
  标注了该注解的类型满足函数式接口的要求。

However, the compiler will treat any interface meeting the definition of a functional interface as a functional interface regardless of whether or not a FunctionalInterface annotation is present on the interface declaration.
然而，无论接口声明中是否存在@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.天然的策略模式(Strategy Pattern)

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

• stream中的lambda

public class LambdaTest {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        //过滤出偶数
        list = list.stream().filter(i -> i%2==0).collect(Collectors.toList());
        //也可以过滤出奇数，这就是不同的过滤策略
        //list = list.stream().filter(i -> i%2==1).collect(Collectors.toList());
        //也可以引用已存在的方法
        //list = list.stream().filter(LambdaTest::test).collect(Collectors.toList());
        list.forEach(System.out::println); //2
    }

    public static boolean test(int i){
        return i%2==0;
    }
}

//list.stream().filter
Stream<T> filter(Predicate<? super T> predicate);

//list.forEach
default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

//System.out::println引用的方法
public void println(Object x) {
   String s = String.valueOf(x);
    if (getClass() == PrintStream.class) {
        writeln(String.valueOf(s));
    } else {
        synchronized (this) {
            print(s);
            newLine();
        }
    }
}

• 自定义使用lambda

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.柯里化(Currying)

柯里化即把一部分参数固化在函数内部，本质就是闭包持有的外部变量
百科：在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。

• 定义一个实现柯里化的方法：

public static Function<Integer, Integer> addWith(int b) {
    //柯里化将参数b固定，返回一个函数，该函数接收参数a，返回a+b
    return a -> add(a, b);
}

public static int add(int a, int b){
    return a+b;
}

• 测试：

public static void main(String[] args) {
    //创建一个Lambda函数，将第二个参数固定为100
    Function<Integer, Integer> addWith100 = addWith(100); //add(a,b) ---> add(a,100)
    //多次调用函数完成加法操作
    Integer sum1 = addWith100.apply(10);
    Integer sum2 = addWith100.apply(20);
    System.out.println("sum1 = " + sum1 + ", sum2 = " + sum2);

    //再创建一个Lambda函数，将第二个参数固定为200
    Function<Integer, Integer> addWith200 = addWith(200); //add(a,b) ---> add(a,200)
    sum1 = addWith200.apply(10);
    sum2 = addWith200.apply(20);
    System.out.println("sum1 = " + sum1 + ", sum2 = " + sum2);
}

• 输出：

sum1 = 110, sum2 = 120
sum1 = 210, sum2 = 220

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

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

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

int count = 0;
Runnable r = () -> {
    System.out.println(count); //也会编译错误
};
count ++; //修改了count
r.run();

• 可修改为：

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"或"super”
在引用构造方法时，方法名为"new"

• 引用静态方法

类名::静态方法名

• 引用构造方法

类名::new

• 引用实例方法

对象名::实例方法名
类名::实例方法名

• 引用当前对象的实例方法

this::实例方法名

• 引用父类的实例方法

super::实例方法名

• 代码示例

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));//引用对象的实例方法
    }
}

• 打印结果：

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

2.静态方法和实例方法引用

• 引用"类::静态方法"：所需lambda与静态方法的入参和返回一致即可
• 引用"对象::静态方法"：不支持，编译错误
• 引用"对象::实例方法"：所需lambda与实例方法的入参和返回一致即可
• 引用"类::实例方法"：支持，但和引用"对象::实例方法"有一些区别，如下

a.需要在实例方法对应的范式上增加一个入参；
b.位置必须在参数列表的第一个；
c.并且该参数为当前类 T 对应的一个实例 t 。
比如：
如果t::method的范式为Supplier<U>，则T::method的范式为 Function<T, U>
如果t::method的范式为Consumer<U>，则T::method的范式为 BiConsumer<T, U>

• 代码示例

package com.vz.demo.test;

public class Man {
    public void hello(String name){
        System.out.println("hello "+name);
    }
}

package com.vz.demo.test;

public class User extends Man {
	private String name;

    public User() { }

    public User(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static User getUser(String name) {
        return new User(name);
    }
	
	public void sayHello(){
        sayHello(super::hello);//引用父类的实例方法
    }

    public void sayHello(Consumer<String> consumer){
        consumer.accept(this.name);
    }
}

package com.vz.demo.test;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;


public class LambdaTest {

    public static void main(String[] args) {
        User zhangsan = new User("张三");

        //对象不能引用静态方法
        //编译错误：Static method referenced through non-static qualifier
        //User lisi= getLisi(zhangsan::getUser);//引用对象的静态方法

        User lisi = getLisi(User::getUser);//引用类的静态方法

        // public String getName() {
        //     return name;
        // }
        String userName1 = getUserName(lisi, User::getName);//引用类的实例方法：Function<User, String>
        String userName2 = getUserName(lisi::getName);//引用对象的实例方法：Supplier<String>
        System.out.println("userName1: " + userName1);
        System.out.println("userName2: " + userName2);

        // public void setName(String name) {
        //     this.name = name;
        // }
        User user1 = new User(), user2 = new User();
        setUserName(user1, "王五", User::setName);//引用类的实例方法：BiConsumer<User,String>
        setUserName("赵六", user2::setName);//引用对象的实例方法：Consumer<String>
        System.out.println("user1.name: "+user1.getName());
        System.out.println("user2.name: " + user2.getName());

		user1.sayHello();//调用父类成员方法
    }

    public static User getLisi(Function<String,User> f){
        return f.apply("李四");
    }

    public static String getUserName(User user, Function<User, String> f){
        return f.apply(user);
    }

    public static String getUserName(Supplier<String> s){
        return s.get();
    }

    public static void setUserName(User user, String name, BiConsumer<User,String> c){
        c.accept(user, name);
    }

    public static void setUserName(String name, Consumer<String> c){
        c.accept(name);
    }
}

• 打印结果

userName1: 李四
userName2: 李四
user1.name: 王五
user2.name: 赵六
hello 王五