Springboot3（一、lambda、::的应用）

Spring Boot 支持 Lambda 函数式编程，好处：

• 简洁性：使用 Lambda 表达式可以大大减少代码的冗余。Lambda 表达式可以将一个功能单元以更简洁的方式传递给方法或函数接口，不需要显式地声明匿名内部类，从而减少了样板代码。
• 可读性：Lambda 表达式可以使代码更加易读和易理解。通过使用简洁的语法，可以更清晰地表达代码的意图，提高代码的可读性。
• 函数式编程风格：Lambda 表达式使得函数式编程范式更容易实现。通过使用函数接口（Functional Interface）作为方法的参数类型，可以更方便地使用 Lambda 表达式来处理集合、过滤数据等操作，从而使代码更加简洁和可维护。
• 并行处理：Lambda 表达式可以很容易地与 Java 8 中引入的并行处理框架结合使用，实现更高效的并行计算。通过并行处理，可以充分利用多核处理器的优势，提高程序的性能。
• 更好的代码组织：使用 Lambda 表达式可以将代码逻辑更好地组织起来，提高代码的模块化和可重用性。通过将功能单元封装在 Lambda 表达式中，可以将代码逻辑组织得更加紧凑和一致。

一、使用lambda简化实例创建

• lambda表达式适用于函数式接口
• 函数式接口：接口中只有一个未实现的接口
• FunctionalInterface注解可以判断接口是否是函数式接口

1.语法：

(参数) ->  {
	方法体;
	return 返回值;
};

lambda可以根据参数，返回值内容不同，简化程度不同：

• 无参：() -> {方法体;return 返回值;};
• 单个参：参数 -> 返回值;
• 多个参(参数不需要定义类型)：(参数,参数……) -> {方法体;return 返回值;};
• 方法体如果只有一句话，可以省略{}。

2.示例：

package com.example.lambda;

interface SumTest {
    int sum(int i, int j);
}

interface EmptyTest {
    int sum();
}

// FunctionalInterface 检查是否是函数式接口
@FunctionalInterface
interface ManyTest {
    int sum(int i);

    // 当接口中出现多个未实现方法的时候，就不算函数式接口了，使用lambda会报错
    //int add();

    // 实现方法，默认返回1
    default int add(){return 1;}
}

class SumTestImpl implements SumTest {

    @Override
    public int sum(int i, int j) {
        return i * j;
    }

}
/**
 * 使用lambda简化实例创建代码
 * 1.lambda表达式适用于函数式接口
 * 2.函数式接口：接口中只有一个未实现的接口
 * 语法：（参数） -> {方法体;返回值;};
 */
public class Lambda {

    public static void main(String[] args) {
        // 普通方式
        SumTestImpl sum = new SumTestImpl();
        System.out.println(sum.sum(1, 6));
        // 普通方式
        SumTest sum1 = new SumTest() {
            @Override
            public int sum(int i, int j) {
                return i * j;
            }
        };
        System.out.println(sum1.sum(2, 6));

        // lambda方式：方法体可以自定义
        SumTest sumLambda = (int i, int j) -> {
            return i * j;
        };
        System.out.println(sumLambda.sum(3, 6));

        // lambda方式，简化参数类型写法
        SumTest sumLambda1 = (i, j) -> {
            return i * j + i * j;
        };
        System.out.println(sumLambda1.sum(3, 6));

        // 单个参数时，不需要小括号
        ManyTest test = i -> {
            return i+i;
        };
        System.out.println(test.sum(3));

        // 单个参数，最简写法
        test = i -> i+i;
        System.out.println(test.sum(3));

        // 无参时，直接小括号即可
        EmptyTest empty = () -> {
            return 1;
        };
        System.out.println(empty.sum());

    }
}

3.Function包

Function中包含着很多函数式接口供我们使用，下面将例举几个：

• Function<T, R>：
  R apply(T t)：对给定的参数类型 T 进行操作，并返回一个结果类型为 R 的值。
• BiFunction<T, U, R>：
  R apply(T t, U u)：对给定的参数类型 T 和 U 进行操作，并返回一个结果类型为 R 的值。
• UnaryOperator（继承自 Function<T, T>）：
  T apply(T t)：对给定的参数类型 T 进行操作，并返回一个结果类型仍为 T 的值。
• BinaryOperator（继承自 BiFunction<T, T, T>）：
  T apply(T t1, T t2)：对给定的参数类型 T 进行操作，并返回一个结果类型仍为 T 的值。
• Predicate：
  boolean test(T t)：对给定的参数类型 T 进行条件判断，返回一个 boolean 值。
• BiPredicate<T, U>：
  boolean test(T t, U u)：对给定的参数类型 T 和 U 进行条件判断，返回一个 boolean 值。
• Consumer：
  void accept(T t)：对给定的参数类型 T 进行处理，没有返回值。
• BiConsumer<T, U>：
  void accept(T t, U u)：对给定的参数类型 T 和 U 进行处理，没有返回值。
• Supplier：
  T get()：获取一个类型为 T 的结果，常用于延迟计算或提供默认值。
• Runnable：
  void run()：执行一些简单的代码块，没有参数和返回值。

3.1 有入参，有返回值【多功能函数】

Function源码如下：

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

使用示例

Function<Integer, String> function = i -> "使用apply方法，i是入参，此处是返回值"+i;
function.apply(1);

3.2 有入参，无返回值【消费者】

BiConsumer源码如下：

@FunctionalInterface
public interface BiConsumer<T, U> {

    /**
     * Performs this operation on the given arguments.
     *
     * @param t the first input argument
     * @param u the second input argument
     */
    void accept(T t, U u);
}

使用示例

BiConsumer<Integer, String> biConsumer = (c, str) -> System.out.println("使用BiConsumer实现有参，无返回值");
biConsumer.accept(1,"test");

3.3 无入参，有返回值【提供者】

Supplier源码如下：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用示例

var list = new ArrayList<Integer>();
list.add(322);
list.add(452);
list.add(621);
list.add(846);
list.add(223);
Collections.sort(list, Integer::compareTo);
Supplier<List> supplier = () -> list;
System.out.println(supplier.get());

3.4 无入参，无返回值

Runnable源码如下：

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface {@code Runnable} is used
     * to create a thread, starting the thread causes the object's
     * {@code run} method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method {@code run} is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

使用示例

Runnable runnable = () -> System.out.println("run起来");
runnable.run();

二、类::方法的使用

public static void main(String[] args) {
    var list = new ArrayList<Integer>();
    list.add(322);
    list.add(452);
    list.add(621);
    list.add(846);
    list.add(223);
    Collections.sort(list,(o1, o2) -> o1.compareTo(o2));
    Collections.sort(list, Integer::compareTo);
}

Integer::compareTo == (o1, o2) -> o1.compareTo(o2)，就是引用Integer中的compareTo方法进行排序。
此处可以直接使用”::“进行简化。

三、综合练习

判断字符是否为数字，如果是数字就打印出来。

    public static void main(String[] args) {
        // 使用supplier输出一个字符
        Supplier<String> supplier = () -> "111";
        // 使用断言判断是否为数字
        Predicate<String> predicate = str -> str.matches("\\d+");
        // 字符串转数字
        Function<String, Integer> function = Integer::parseInt;
        // 消费数据
        Consumer<Integer> co = c -> {
            System.out.println("输入的字符是数字："+c);
        };
        String str = supplier.get();
        if(predicate.test(str)){
            co.accept(function.apply(str));
        }else{
            System.out.println("输入的字符不是数字");
        }
	}

总结

java util function包下的所有function定义：

• Consumer: 消费者
• Supplier:提供者
• Predicate: 断言

get/test/apply/accept调用的函数方法；