java8新特性之Lambda表达式

Lambda

 lambda是一个匿名函数（方法），我们可以把lambda表达式理解为，一段可以传递的代码。

java8中引入了一个新的操作符“->”该操作符将Lambda表达式拆分为两部分。

• 左侧：Lambda表达式的参数列表
• 右侧：Lambda表达式中所需执行的功能，即Lambda体。

Lambda表达式需要“函数式接口”的支持。
函数式接口：接口中只有一个抽象方法。可以使用注解@FunctionalInterface修饰

语法格式

语法格式一：无参数，无返回值
() -> System.out.println("Hello Lambda!");

    public void test10(){
        int num = 99; //在jdk1.8以前，规则：在局部内部类中用了同级别的局部变量时，该变量必须被final修饰。
                        //jdk1.8之后，不需要手动final修饰了，自动final修饰。

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!" + num);
            }
        };
        r.run();
        System.out.println("------------");
        Runnable r1 = () -> System.out.println("Hello Lambda!" + num);
        r1.run();
    }

语法格式二：有一个参数，并且无返回值。
(x) -> System.out.println(x);

    @Test
    public void test11(){
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("一定要nb");
    }

语法格式三：若只有一个参数，小括号可以省略不写
x -> System.out.println(x);

    @Test
    public void test12(){
        Consumer<String> con = x -> System.out.println(x);
        con.accept("一定要nb");
    }

语法格式四：有两个及以上的参数，有返回值，并且Lambda体中有多条语句。

@Test
    public void test13(){
        Comparator<Integer> comparator = (x, y) -> {
            System.out.println("一定要nb");
            return Integer.compare(x,y); 
        };
    }

语法格式五：若Lambda体中只有一条语句，return和大括号都可以省略不写。

   @Test
    public void test14(){
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x,y);
    }

语法格式六：Lambda中的 参数列表的数据类型可以不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断”。

Lambda实例

感兴趣的小伙伴可以看看下面的示例哦，直观感受一下lambda表达式。
要用到的Javabean:

//员工信息类
public class Employee {
    private String name;
    private Integer age;
    private Double salary;//工资
    public Employee(){

    }
    public Employee(String name, Integer age, Double salary){
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge(){
        return age;
    }
    public void setAge(Integer age){
        this.age = age;
    }
    public void setSalary(Double salary){
        this.salary = salary;
    }
    public Double getSalary(){
        return salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

公司员工信息：

List<Employee> employees = Arrays.asList(
            new Employee("张三",18,3318.44),
            new Employee("李四",15,2238.44),
            new Employee("王五",16,5627.44),
            new Employee("赵六",23,9274.44),
            new Employee("田七",54,8888.44)
    );

需求1：获取公司员工年龄大于35的员工信息
需求2：获取当前公司中员工工资大于5000的员工信息

//获取当前公司中员工工资大于5000的员工信息
    public List<Employee> filterEmployees2(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(emp.getSalary() > 5000){
                emps.add(emp);
            }
        }
        return emps;
    }
    @Test
    public void test3(){
        List<Employee> emps = filterEmployees2(employees);
        for (Employee employee : emps){
            System.out.println(employee);
        }
    }
 //获取公司员工年龄大于35的员工信息
    public List<Employee> filterEmployees(List<Employee> list){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(emp.getAge() >20){
                emps.add(emp);
            }
        }
        return emps;
    }
    @Test
    public void test2(){
        List<Employee> emps = filterEmployees(employees);
        for (Employee employee : emps){
            System.out.println(employee);
        }
    }

这个就是我们初学者一般使用的方法了。

在用Lambda表达式优化代码之前呢，先讲另一种优化的方式：
策略涉及模式+匿名内部类：
首先写一个只有一个方法的接口。

public interface MyPredicate<T> {
    public boolean test(T t);
}

然后实现需求：

    public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(mp.test(emp)){
                emps.add(emp);
            }
        }
        return emps;
    }
 @Test
    public void test6(){
        List<Employee> emps =filterEmployee(employees, new MyPredicate<Employee>(){
            @Override
            public boolean test(Employee employee) {
                return employee.getAge()<20;
            }
        });
        for(Employee employee: emps){
            System.out.println(employee);
        }
    }
    @Test
    public void test7(){
        List<Employee> emps =filterEmployee(employees, new MyPredicate<Employee>(){
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary()<5000;
            }
        });
        for(Employee employee: emps){
            System.out.println(employee);
        }
    }

接下来就是使用Lambda表达式来将上述的匿名内部类写的更简洁。

   public List<Employee> filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
        List<Employee> emps = new ArrayList<>();
        for (Employee emp : list){
            if(mp.test(emp)){
                emps.add(emp);
            }
        }
        return emps;
    } 
@Test
    public void test8(){
        List<Employee> emps = filterEmployee(employees,(e) -> e.getSalary() < 5000);
        emps.forEach(System.out::println);
    }

当然还有更加简便的方式，Stream API

    @Test
    public void test9(){
        employees.stream()
                .filter((e)->e.getSalary()<5000)
                .forEach(System.out::println);
    }