java8之Lambda表达式

（一）Java 8 新特性简介

• 速度更快
• 代码更少（增加了新的语法 Lambda  表达式）
• 强大的 Stream API
• 便于并行
• 最大化减少空指针异常 Optional
• 其中最为核心的为 Lambda 表达式与Stream API

（二）Lambda  表达式

为什么使用 Lambda  表达式？

• Lambda 是一个 匿名函数，我们可以把 Lambda表达式理解为是 一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。
• 使用Lambda表达式替换匿名内部类，使代码看起来更简洁。

Lambda  表达式语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：
左侧：指定了 Lambda 表达式需要的所有参数(左侧是匿名方法，可以有参数或无参数)
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。(右侧是方法体，如果只有一条语句可以省略{}，否则需要加上{})

语法格式一 ：无参，无返回值，Lambda

Runnable runnable = ()-> System.out.println("Hello Lambda !");

语法格式二 ：Lambda需要一个参数

 Consumer<String> consumer = (args)-> System.out.println("args = " + args);

语法格式三 ：Lambda  只 需 要一个参数时，参数的小括号可以省略

Consumer<String> consumer = args-> System.out.println("args = " + args);

语法格式四 ：Lambda  需要两个参数，并且有返回值

BinaryOperator<Long> binaryOperator = (x,y)->{
            System.out.println("实现函数接口方法！");
            return x+y;
        };

语法格式五 ： 当 Lambda  体只有 一条 语句时，return  与大括号

BinaryOperator<Long> binaryOperator = (x,y)->x+y;

语法格式六 ：传入的参数可以省略

 //Long类型可以省略
        BinaryOperator<Long> binaryOperator = (Long x,Long y)->{
            System.out.println("实现函数接口方法！");
            return x+y;
        };

（三）Lambda表达式的使用

“Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。

Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。

演示

List<Employee> emps = Arrays.asList(
                new Employee(102, "李四", 59, 6666.66),
                new Employee(101, "张三", 18, 9999.99),
                new Employee(103, "王五", 28, 3333.33),
                new Employee(104, "赵六", 8, 7777.77),
                new Employee(105, "田七", 38, 5555.55)
        );
        //匿名内部类
        Comparator<Employee> comparator = new Comparator<Employee>() {
            //按年龄升序 compareTo大于等于1，小于等于-1，等于就是0
            @Override
            public int compare(Employee employee1, Employee employee2) {
                // 降序
                // return employee2.getAge()-employee1.getAge();
                // return employee2.getAge().compareTo(employee1.getAge());

                //升序
                //return employee1.getAge()-employee2.getAge();
                return employee1.getAge().compareTo(employee2.getAge());

            }
        };
        Collections.sort(emps,comparator);
        System.out.println("匿名内部类中emps = " + emps);

        //使用Lambda表达式
        Collections.sort(emps,(employee1,employee2)->employee1.getAge().compareTo(employee2.getAge()));
        System.out.println("使用Lambda表达式emps = " + emps);

        //Stream API+Lambda对集合中的年龄降序
        List<Employee> list = emps.stream().sorted((employee2, employee1) -> employee2.getAge().compareTo(employee1.getAge())).collect(Collectors.toList());
        System.out.println("年龄降序list = " + list);

（四）java8自定义函数

函数接口：JDK1.8的特性，有且只有一个抽象方法的接口就是函数接口

@FunctionalInterface：该注解用于编译器校验该函数接口是否合法即用于限制一个接口中只有一个抽象方法方法

public class LambdaTest {

    /**
     * 自定义函数
     */
    @FunctionalInterface
    interface MyFunction<T,U,R> {
        //求和
        R add(T t, U u);
    }
    @Test
    public void test(){
        //JAVA 8 之前一般是用匿名类实现
        MyFunction myFunction = new MyFunction() {
            @Override
            public Object add(Object o1, Object o2) {
                return (int) o1+ (int)o2;
            }
        };
        int sum = (int)myFunction.add(1, 1);
        System.out.println("sum = " + sum);
    }
    //自定义函数的使用
    public int add(int a,int b,MyFunction<Integer, Integer, Integer>myFunction){

        return myFunction.add(a,b);
    }
    @Test
    public void testAdd(){
        int result = add(1, 1, (a, b) -> {
            return a + b;
        });
        System.out.println("result = " + result);
    }
}

(五) java8方法引用

参考：Java8新特性之二：方法引用