Day 18 (Lambda表达式的使用)

/**
 * Lambda表达式的使用举例
 * 
 *      格式：
 *          -> : Lambda操作符
 *          ->左边: Lambda形参列表，即接口中的抽象方法的形参列表
 *          ->右边: Lambda体，即重写的抽象方法的方法体
 *
 *      使用：
 *          1、无参，无返回值
 *          2、Lambda需要一个参数，无返回值
 *          3、数据类型可以省略，“类型推断”
 *          4、Lambda只需要一个参数，参数小括号可以省略
 *          5、Lambda需要两个或两个以上的参数，多条执行语句，可以有返回值
 *          6、Lambda体只有一条语句，return与大括号若有，都可以省略
 *
 *      本质：作为函数式接口的实例
 *
 * 如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口
 */

Lambda举例

    //1、无参，无返回值
    @Test
    public void test1(){
        //提供Runnable接口匿名实现类的对象
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("I love myself");
            }
        };
        r1.run();
        Runnable r2 = () -> {
            System.out.println("yeah~~~");
        };
        r2.run();
    }

    //2、Lambda需要一个参数，无返回值
    @Test
    public void test2(){
        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("try harder");

        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("I WILL");

    }

    //3、数据类型可以省略，“类型推断”
    @Test
    public void test3(){
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("没有省略类型");

        Consumer<String> con2 = (s) ->{
            System.out.println(s);
        };
        con2.accept("省略参数类型");
    }

    //4、Lambda只需要一个参数，参数小括号可以省略
    @Test
    public void test4(){
        Consumer<String> con1 = (s) -> {
            System.out.println(s);
        };
        con1.accept("只有一个参数 没有省略小括号");

        Consumer<String> con2 = s -> {
            System.out.println(s);
        };
        con2.accept("只有一个参数 省略了小括号");
    }

    //5、Lambda需要两个或两个以上的参数，多条执行语句，可以有返回值
    @Test
    public void test5(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }

        };
        System.out.println(com1.compare(12,34));

        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        System.out.println(com2.compare(45, 7));
    }

    //6、Lambda体只有一条语句，若有return与大括号，两者都可以省略
    @Test
    public void test6(){
        Comparator<Integer> com1 = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        System.out.println(com1.compare(45, 7));
        //example1:
        Comparator<Integer> com2 = (o1, o2) -> o1.compareTo(o2); //省略了大括号和return关键字
        System.out.println(com2.compare(7, 7));
        //example2:
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("只有一条语句，省略大括号");
    }

函数式接口： 

/**
 * java内置的4大核心函数式接口(只包含一个抽象方法成为函数式接口，可以通过Lambda表达式来创建该接口的实现对象)
 *      消费型接口 Consumer<T>       void accept(T t)
 *      供给型接口 Supplier<T>       T get()
 *      函数型接口 Function<T, R>    R apply(T t)
 *      断定型接口 Predicate<T>      boolean test(T t)
 */

        （1）消费型接口举例

    @Test
    public void test5(){
    //一般写法
        Consumer<Double> consumer = new Consumer<>() {
            @Override
            public void accept(Double d) {
                System.out.println("消费：" + d +"元");
            }
        };
        consumer.accept(900.9);

        //Lambda写法
        Consumer<Double> consumer1 = aDouble -> System.out.println("消费：" + aDouble +"元");
        consumer1.accept(78.9);
    }

        （2）供给型接口举例

public List addNum(int size, Supplier<Integer> s){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            list.add(s.get());
        }
        return list;
    }
    @Test
    public void test6(){
        //一般写法
        List list = addNum(10, new Supplier<Integer>() {
            @Override
            public Integer get() {
                return (int) (Math.random() * 100);  //[0,1)--[0,100)
            }
        });
        //Lambda
        List list1 = addNum(10,()->(int) (Math.random() * 100));
        list1.forEach(t-> System.out.println()); //Lambda写法的输出
        list1.forEach(System.out::println);  //方法引用的写法输出
    }

        （3）函数型接口举例

    //Function<T, R>    R apply(T t)
    public String handler(String i, Function<String,String> f){
        return f.apply(i);
    }
    @Test
    public void test7(){
        //一般写法：
        handler("ac", new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        });
        //Lambda
        String s1 = handler("ac", s -> s.toUpperCase());
        System.out.println(s1);
    }

        （4）断定型接口举例

    
    public List<String> filterString(List<String> list, Predicate<String> pre){
        ArrayList<String> filterList = new ArrayList<>();
        for (String s : list) {
            if (pre.test(s)){  //test()结果为true则将该元素值加入到filterList中去
                filterList.add(s);
            }
        }
        return filterList;
    }    


    //Predicate<T>      boolean test(T t)
    @Test
    public void test8(){
        List<String> list = Arrays.asList("abc", "ab", "aa", "bbcc", "djow", "eoioe", "hjk");
        //普通写法
        filterString(list, new Predicate<String>() {
            @Override

            public boolean test(String s) {
                return s.length()>3;//判断list中长度大于3的字符串  满足则返回true
//                return s.contains("a");//判断list字符数组中包含a的字符串
            }
        });
        //Lambda写法
        List<String> list1 = filterString(list, s -> s.length() > 3);
        list1.forEach(t-> System.out.println()); //Lambda输出写法
        list1.forEach(System.out::println);  //方法引用输出写法
    }