Lambda表达式

1.语法

• (参数列表) -> 表达式
• (参数列表) -> {方法体}

2.函数式接口

Lambda表达式只能用于函数式接口，即那些只包含一个抽象方法的接口。

函数式接口必须满足以下条件

• 只有一个抽象方法
• 可以包含多个默认方法和静态方法(这些不会影响其函数式的特性)
• 使用@FunctionalInterface注解来标注，虽然不是强制性的，但它可以确保编译器检查该接口是否符合函数式接口的定义。

@FunctionalInterface
public interface MyFunctionalInterface {
    void myMethod();  // 抽象方法
}
MyFunctionalInterface myFunc = () -> System.out.println("Hello from Lambda!");
myFunc.myMethod();  // 输出：Hello from Lambda!

3.预定义的函数式接口

• Supplier<T>
  • 无参数，返回类型为T的值。
  • 常用于延迟计算或提供对象实例。

@FunctionalInterface
public interface Supplier<T> {
    T get();
}
Supplier<String> supplier = () -> "Hello, Supplier!";
System.out.println(supplier.get());

• Consumer<T>
  • 接受一个参数，但没有返回值。
  • 常用于对传入对象进行操作（例如打印、修改等）。

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("Hello, Consumer!");  // 输出：Hello, Consumer!

• Function<T, R>
  • 接收一个类型为T的参数，返回一个类型为R的值。
  • 常用于对象转换或计算。

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}
Function<Integer, String> function = num -> "Number: " + num;
System.out.println(function.apply(5));  // 输出：Number: 5

• Predicate<T>
  • 接受一个参数，返回一个boolean值。
  • 常用于条件判断和过滤。

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}
Predicate<Integer> isEven = num -> num % 2 == 0;
System.out.println(isEven.test(4));  

• BiFunction<T, U, R>
  • 接收两个参数，返回一个结果。
  • 适合处理两个参数之间的关系。

@FunctionalInterface
public interface BiFunction<T, U, R> {
    R apply(T t, U u);
}
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
System.out.println(add.apply(3, 5));  // 输出：8

• Runnable
  • 无参数也无返回值的接口，常用于线程执行。

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
Runnable runnable = () -> System.out.println("Running in thread");
runnable.run();  // 输出：Running in thread

4.普通方法抽象为函数式接口

将普通方法抽象为函数式接口的几个步骤

• 定义一个函数式接口
• 确保普通方法的签名（包括参数类型、返回值类型）与函数式接口的抽象方法匹配
• 通过lambda 表达式或者方法引用将该方法作为该函数式接口的实现。

public void test() {
    Function<Integer, String> converter = this::intToString;
	String result = converter.apply(5);
}

public String intToString(Integer number) {
    return "Number: " + number;
}

输出 "Number: 5"

只要自定义方法的参数和返回值与某个函数式接口的抽象方法相符，你就可以将该方法抽象为这个函数式接口的实现。

应用场景:
test1和test2有很多共性的操作，我们希望抽取出一个公共方法。

@RestController
@RequestMapping("/demo")
public class DemoController {

    @Autowired
    private Service service;

    @GetMapping(value = "/test1")
    public void test1() {
        // 共性操作
        checkParam()
        // 业务逻辑, 并返回一个List
        List<user> users = service.queryUser("1");
        // 共性操作
        sendMessage(users)
    }

    @GetMapping(value = "/test2")
    public void test2() {
        // 共性操作
        checkParam()
        // 业务逻辑, 并返回一个List
        List<Role> roles= service.queryRole("1");
        // 共性操作
        sendMessage(roles)
    }
}

解决思路: 把不同的业务逻辑，封装成一个方法，并抽象为函数式接口，作为参数传递。

@RestController
@RequestMapping("/demo")
public class DemoController {

    @Autowired
    private Service service;

    @GetMapping(value = "/test1")
    public void test1() {
    	Function<String, List<user>> function = service::queryUser;
        doTest(function);
    }

    @GetMapping(value = "/test2")
    public String test2() {
    	Function<String, List<Role>> function = service::queryRole;
        doTest(function);
    }
    
    // 公共方法
	private <T> void doTest(Function<String, List<T>> function) {
        // 共性操作
        checkParam()
        // 函数式接口
		List<T> result = queryFunction.apply("1");
        // 共性操作
        sendMessage(roles)
    }
}