Java Lambda 表达式

lambda表达式

1.举例：(o1, o2) -> Integer.compare(o1, o2)

2. 格式
　　-> :lambda操作符或者箭头操作符
　　->左边 :lambda形参列表（其实就是接口中的抽象方法的形参列表）
　　->右边 :lambda体（其实就是重写的抽象方法的方法体）

3.lambda表达式的本质：作为函数式接口实现类的实例

4.lambda表达式的使用：
分几种情况：

public class Lambda01 {

    @Test
    public void test01(){
        // 无参数，无返回值
        Runnable run = ()-> System.out.println("无返回值");
        run.run();

        // 有参数，无返回值（数据类型可省略，有接口可推断出类型）
        Consumer<String> consumer = (s) -> {System.out.println(s);};
        consumer.accept("有参数，无返回值");

        // 若只有一个参数，参数的小括号可省略
        Consumer<String> consumer1 = s -> {System.out.println(s);};
        consumer.accept("省略小括号");

        // 可以有两个或以上的参数，多条执行语句，而且可以有返回值
        //传统匿名内部类写法
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        // lambda写法
        Comparator<Integer> comparator1 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
           return o1.compareTo(o2);
        };
        System.out.println(comparator1.compare(12, 21));

        // 当lambda体只有一条语句时，return 与大括号都可以省略
        Comparator<Integer> comparator2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(comparator2.compare(22, 21));
    }

总结：
　　->左边：lambda形参列表类型可以省略(类型推断)，如果lambda形参只有一个参数，可以省略括号
　　->右边：lambda体应该使用一对{}包裹，如果lambda体只有一条执行语句(可能是return语句)，大括号和return都可以省略。

5.函数式接口
如果一个接口只有一个抽象方法，那么该接口就是函数式接口
可通过lambda表达式来创建该接口的对象

Java一直倡导“一切皆对象”
6.所以以前用匿名实现类表示的现在都可以用lambda表达式来写

7.函数式接口
java内置四大核心函数式接口

public class lambda02 {

    @Test
    public void test(){

        happyTime(500, d-> System.out.println("学习太累了"));

        List<String> stringList = Arrays.asList("北京", "天津", "南京", "东京", "普京");
        List<String> list = filterString(stringList, s -> s.endsWith("京"));
        System.out.println(list);

        List<String> upperStrings = stringUpper(Arrays.asList("hello", "java"), x -> x.toUpperCase());
        System.out.println(upperStrings);
    }

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

    // 根据给定的规则，过滤集合中的字符串，此规则有Predicate的test方法决定
    public List<String> filterString(List<String> list, Predicate<String> predicate){
        List<String> filterList = new ArrayList<>();
        for (String s: list) {
            if(predicate.test(s)){
                filterList.add(s);
            }
        }
        return filterList;
    }

    // 根据给定的规则，加工集合中的字符串，此加工规则有Function（根据自变量x，输出因变量y 类似于y = ax + b的关系）
    // 的方法决定
    public List<String> stringUpper(List<String> list, Function<String, String> function){
        List<String> newArrayList = Lists.newArrayList();
        for (String s: list){
            newArrayList.add(function.apply(s));
        }
        return newArrayList;
    }
}