SpringBoot3 从入门到实践

一、Lambda表达式与函数式接口

1、定义的一个接口只有一个方法称为函数式接口

2、idea注解判断是否为函数式接口: @FunctionInterface

3、示例

Interface MyInterface{

sum(int i, int j);

}

psvm {

MyInterface interface = (i, j) -> {

return i*i + j*j;

sout(interface.sum(2,3));

}

}

二、JAVA内置函数式接口

1、消费者（Consumer）

如名字所示，只是消费一个参数，没有任何返回

Consumer consumer = (x) -> sout("消费者今天消费了:" + x);

consumer.accept(10);

2、提供者（Supplier）

如名字所示，不接收任何参数，只是提供一个返回值

Supplier supplier = () -> {return "这是一个提供者"};

sout(supplier.get());

3、断言（Predicate）

如名字所示，判断一条语句的真假，返回一个Boolean类型

Predicate predicate = (x) -> (x % 2 == 0);

sout(predicate .test(10));

4、函数（Function）

接收一个参数，然后提供一个返回值

Function function = (x) -> x + 2;

sout(function (4));

    public static void main(String[] args) {

        Consumer<Integer> consumer = x -> System.out.println("这是一个消费者  " + x);
        consumer.accept(10);

        Supplier<String> supplier = () -> "这是一个提供者";
        System.out.println(supplier.get());

        Predicate<Integer> predicate = x -> x % 2 == 0;
        System.out.println("这是一个断言  " + predicate.test(10));

        Function<Integer, Integer> function = x -> {
            System.out.print("这是一个Function  ");
            return  x + 2;
        };
        System.out.println(function.apply(10));

    }

运行结果实例

判断一个随机数的奇偶性

 public static void main(String[] args) {
       test3(() -> new Random().nextInt(100) + 1,
               x -> x % 2 == 0,
               x -> "*" + x + "*",
               x -> System.out.println("这是一个偶数 " + x));
    }

    public static void test3(Supplier<Integer> supplier,
            Predicate<Integer> predicate,
            Function<Integer, String> function,
            Consumer<String> consumer) {

        int random = supplier.get();
        System.out.println("生成的随机数：" + random);

        if (predicate.test(random)) {
            consumer.accept(function.apply(random));
        } else {
            System.out.println("这不是一个偶数 " + random);
        }
    }

运行结果示例

三、Stream API相关操作

Stream的操作方法可以分为中间操作和终止操作。

中间操作：

1. filter：用于过滤不满足条件的元素。
2. distinct：用于去掉重复的元素。
3. limit：截断流，使其元素不超过给定数量。
4. skip（n）：跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。

终止操作（终端操作）：

1. collect：将流中的元素收集到一个列表中。
2. count：计算流中的元素个数。
3. forEach：对流中的每个元素执行指定的操作。
4. reduce：对流中的元素进行归约操作，得到一个最终结果。
5. max：找到流中的最大值。
6. min：找到流中的最小值。
7. sum：计算流中所有元素的和。
8. anyMatch：检查流中的元素是否满足某个条件，如果满足则返回 true。
9. allMatch：检查流中的元素是否都满足某个条件，如果都满足则返回 true。
10. noneMatch：检查流中的元素是否都不满足某个条件，如果都不满足则返回 true。

filter操作： 

将一个断言作为入参，根据断言返回的Boolean类型筛选所需的数据

map操作：

映射操作，接收一个Function，将入参映射出一组全新的数据

flatMap操作：

打散操作，它用于将一个流中的每个元素转换为一个新的流，然后将所有这些流合并为一个单一的输出流。

@AllArgsConstructor
@Data
class Person {

    private String name;

    private Integer age;
}

public class Test {

    public static void main(String[] args) {

        ArrayList<Person> list = new ArrayList<>();
        list.add(new Person("Alice", 16));
        list.add(new Person("Bob", 17));
        list.add(new Person("Center", 18));
        list.add(new Person("Dog", 19));

        list.stream()  // 开启一个流
                .filter(s -> s.getAge() % 2 == 0)  // 断言作为入参,筛选所有满足条件的数据
                .map((s) -> s.getName())  // Function作为入参,获取一个全新的数据（映射）
                .flatMap(x -> Arrays.stream(x.split("e")))  // Function作为入参,Function的返回值是stream形式（打散）
                .forEach(System.out::println); // 终止操作
    }

}