Java 8 lambda表达式

1、基础语法

-> ：箭头操作符/lambda操作符

" -> " 将lambda表达式拆分成左右两部分

• 左侧为参数列表。
• 右侧为所需要执行的内容：lambda体（接口的实现方法）。
• 接口：函数式接口。只存在一个抽象方法的接口。

函数式接口：可通过@FunctionalInterface进行修饰，当接口非函数式接口时，函数会编译错误、

2、场景

2.1 无参数无返回值的接口

无参数无返回值写法:左侧空括号，右侧实现
() -> System.out.println()

    /**
     *  无参数无返回值写法:左侧空括号，右侧实现
     *  () -> System.out.println()
     */
    @Test
    public void test1(){
        /**
         * jdk1.7之前，匿名内部类引用的数据必须为final
         * 1.8可以不声明，但本质上还是final
         */
        int i = 0;

        //案例
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello"+i);
            }
        };
        runnable.run();

        System.out.println("===========================");
        /**
         * lambda实现
         */
        Runnable runnable1 = ()-> System.out.println("hello world"+i);
        runnable1.run();
    }

2.2 一个参数无返回值写法

左侧为参数（随便命名），右侧为实现
参数小括号可以省略

/**
     * 有一参数无返回值写法
     */
    @Test
    public void test2(){
        Consumer<String> consumer = (x) -> System.out.println(x);
        consumer.accept("superMan");
    }

/**
     * 有一个参数，参数小括号可以省略
     */
    @Test
    public void test3(){
        Consumer<String> consumer = x -> System.out.println(x);
        consumer.accept("superMan");
    }

2.3 多参多返回值多语句写法

参数加括号
语句用大括号包裹
只有一条语句时，大括号可省略
当大括号省略时，return关键字也必须省略

/**
     * 有多个参数，有返回值，且存在多条语句
     */
	@Test
    public void test4() {
        Comparator<Integer> com = (x, y) -> {
            System.out.println("多条语句");
            return Integer.compare(x, y);
        };
        int compare = com.compare(1, 2);
        System.out.println(compare);
    }

/**
     * 有多个参数，有返回值，存在1条语句
     */
    @Test
    public void test5() {
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        int compare = com.compare(1, 2);
        System.out.println(compare);
    }

注：
参数数据类型可以不写，JVM可通过上下文推断出数据类型
但为一个参数增加数据类型时，所用的数据类型都需要指定数据类型

3、实践

接下来，我们通过一个需求来学习lambda表达式：

员工有姓名、年龄和工资三个属性，我们要在员工列表中找出薪资>5000的员工信息。

员工实体类：

public class Employee {
    private String name;
    private int age;
    private double salary;

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}

接口：

@FunctionalInterface
public interface MyInterface<T> {
    public boolean test(T t);
}

实现：

public class FilterEmployeeBySalary implements MyInterface<Employee>{
    @Override
    public boolean test(Employee employee) {
        return employee.getSalary()>5000;
    }
}

整合成lambda表达式：

public class TestLambda {
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,999),
            new Employee("李四",183,9999),
            new Employee("钱五",185,9999),
            new Employee("宋六",184,9999),
            new Employee("孙七",183,9999),
            new Employee("王八",128,999)
    );

    public List<Employee> returnSJMS(List<Employee> list, MyInterface<Employee> employeeMyInterface){
        ArrayList<Employee> arrayList = new ArrayList<>();

        for (Employee employee : list) {
            if (employeeMyInterface.test(employee)){
                arrayList.add(employee);
            }
        }
        return arrayList;
    }

    @Test
    public void test6(){
        List<Employee> employees = returnSJMS(this.employees, (employee) -> employee.getSalary() < 5000);
        for (Employee employee : employees) {
            System.out.println(employee);
        }
    }
}