Lambda表达式

Lambda表达式

本篇博客是学习过程的学习笔记

Lambda常用抽象接口

     * java8 内置的四大核心函数式接口
     *
     * Consumer<T>：消费型接口
     *      void accept(T t);
     *
     * Supplier<T>：供给型接口
     *      T get();
     *
     * Function<T, R>：函数型接口
     *      R apply(T t);
     *
     * Predicate<T>：断言行接口
     *      boolean test(T t);

Lambda例子

/**
 * @Author fxx
 * @Date 2021/10/20 10:14
 */
@SpringBootTest(classes = PushApplication.class)
@RunWith(SpringRunner.class)
public class LambdaTest {
   


    /**
     * ->将lambda分成了2部分
     * 左边：lambda表达式的参数列表
     * 右边：lambda表达式中所需执行的功能，即lambda体
     *
     * 左右遇一括号省
     * 左侧推断类型省
     *
     * Lambda表达式需要函数式接口的支持
     * 函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以使用注解@FunctionalInterface修饰，可以检查是否是函数式接口
     *
     *
     *
     * java8 内置的四大核心函数式接口
     *
     * Consumer<T>：消费型接口
     *      void accept(T t);
     *
     * Supplier<T>：供给型接口
     *      T get();
     *
     * Function<T, R>：函数型接口
     *      R apply(T t);
     *
     * Predicate<T>：断言行接口
     *      boolean test(T t);
     */
    
    
    
    /**
     * 语法格式一：无参数，无返回值
     *  () -> System.out.println("Hello");
     */
    @Test
    public void test01(){
   
        int num = 1;    //如果lambda里使用到了外部类变量，需要是final
        Runnable r = () -> System.out.println("HelloWorld" + num);

        r.run();
    }

    /**
     * 语法格式二：有一个参数，无返回值
     */
    @Test
    public void test02(){
   
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("尚硅谷");
    }

    /**
     * 语法格式三：若只有一个参数，()可以省略
     */
    @Test
    public void test03(){
   
        Consumer<String> con = x -> System.out.println(x);
        con.accept("尚硅谷");
    }

    /**
     * 语法格式四：有两个以上参数，有返回值，并且lambda体中有多条语句，那么lambda体需要用{}包起来
     */
    @Test
    public void test04(){
   
        Comparator<Integer> com = (x, y) -> {
   
            System.out.println("lambda接口");
            return Integer.compare(x, y);
        };
    }

    /**
     * 语法格式五：有两个以上参数，有返回值，若lambda体中只有一条语句，{}和return都可以省略不写
     */
    @Test
    public void test05(){
   
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    }

    /**
     * 语法格式六：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器可以通过上下文推断出数据类型，即“类型推断”
     */
    @Test
    public void test06(){
   
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    }

    /**
     * java8 内置的四大核心函数式接口
     *
     * Consumer<T>：消费型接口
     *      void accept(T t);
     *
     * Supplier<T>：供给型接口
     *      T get();
     *
     * Function<T, R>：函数型接口
     *      R apply(T t);
     *
     * Predicate<T>：断言行接口
     *      boolean test(T t);
     */

    //测试消费型接口
    @Test
    public void test1(){
   
        happy(1000, m -> System.out.println("本次消费："+m + "元"));
    }

    public void happy(double money, Consumer<Double> con){
   
        con.accept(money);
    }

    //测试供给型接口
    @Test
    public void test2(){
   
        List<Integer> list = getNumList(10, () -> (int) (Math.random() * 100));
        for (Integer i:list) {
   
            System.out.println(i);
        }
    }

    public List<Integer> getNumList(int num, Supplier<Integer> sup){
   
        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < num; i++) {
   
            Integer n = sup.get();
            list.add(n);
        }
        return list;
    }

    //测试函数型接口
    @Test
    public void test3(){
   
        String s = strHandler("\t\t\t 尚硅谷", (str) -> str.trim());
        System.out.println(s);
    }

    //需求：用于处理字符串
    public String strHandler(String str, Function<String, String> fun){
   
        return fun.apply(str);
    }

    //测试断言型接口
    @Test
    public void test4(){
   
        List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
        List<String> stringList = filterStr(list, str -> str.length() > 3);
        for (String str :
                stringList) <