【Java8新特性】——Lambda表达式详解

【前言】

Lamda是一个匿名函数，可以把lamda表达式理解为一段可以传递的代码，可以写出简洁，更加灵活的代码。作为一种更加紧凑的代码风格，使Java的语言表达式能力得到了提升。

【内容】

1.为什么要用Lamda表达式？

从案例中我们找出答案：
例如从员工中分别找出工资小于5000的员工，找出年龄大于35的员工；

//员工的集合：
  List employeeList= Arrays.asList(
          new Employee("张三",12,123.12),
          new Employee("李四",38,123.123),
           new Employee("王五",50,123.123),
          new Employee("赵六",16,123.123),
          new Employee("田七",8,123.123)
  );

//员工实体
/**
 * Created by cyl on 2018/6/4.
 */
public class Employee {
    private String name;
    private Integer age;
    private double salary;
    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    /**
     * 获取员工的基本信息
     * @param name
     * @param age
     * @param salary
     */
    public  Employee(String name,Integer age,double salary){
        this.name=name;
        this.age=age;
        this.salary=salary;
    }

    @Override
    public String toString() {
        return super.toString()+"["+this.name+","+this.age+","+this.salary+"]";
    }
}

通过普通的方式

//需求：获取当前公司中员工年龄大于35的年龄
    public List filterEmployeesByAge(List list){
        List emps=new ArrayList<>();
        for (Employee emp : list) {
            if(emp.getAge()>=35) {
                emps.add(emp);
            }
        }
        return emps;
    }

//需求：获取当前公司中员工工资小于5000的人
    public List filterEmployeesBySalary(List list){
        List emps=new ArrayList<>();
        for (Employee emp : list) {
            if(emp.getSalary()>=35) {
                emps.add(emp);
            }
        }
        return emps;
    }

   @Test
    public  void test3(){
        List listAge=filterEmployeesByAge(employeeList);
        List listSalary=filterEmployeesBySalary(employeeList);

    }

注：这种方式非常明显出现代码冗余，除了比较的条件（年龄和工资不同外，其他都是相同的）

抽出比较的条件，使用策略模式的方法

1.创建比较接口

package com.cyl.Lamda;

/**
 * Created by cyl on 2018/6/4.
 */
public interface MyPredicate {
     boolean test(T t);
}

根据具体的比较条件实例化test方法：【FilterEmployeeByAge】和【FilterEmployeeBySalary】

package com.cyl.Lamda;

/**
 * Created by cyl on 2018/6/4.
 */
public class FilterEmployeeByAge implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee employee) {
        return employee.getAge()>35;
    }
}

package com.cyl.Lamda;

/**
 * Created by cyl on 2018/6/4.
 */
public class FilterEmployeeBySalaryimplements MyPredicate<Employee> {
    @Override
    public boolean test(Employee employee) {
        return employee.getSalary()>35;
    }
}

3.重构filterEmployee方法

 public  List  filterEmployee(List list,MyPredicate mp){
      List employees=new ArrayList<>();
     for (Employee employee : list) {
         if(mp.test(employee)){
             employees.add(employee);
         }
     }
       return  employees;
 }

4.测试：

/**
 * 优化方式一：通过策略设计模式
 */
  public void test4(){
     filterEmployee(employeeList,new FilterEmployeeByAge());
     filterEmployee(employeeList,new FilterEmployeeBySalary());
}

注：这种方法比上一种方法抽象了，但是感觉代码也不少，每一次添加一个比较条件都要添加一个类，而且使用的时候还需要实例化。

匿名内部类直接测试

//优化方式二：匿名内部类
  @Test
    public  void test5(){
    //匿名内部类
   List list= filterEmployee(employeeList, new MyPredicate() {
         @Override
         public boolean test(Employee employee) {
             return employee.getSalary()<=5000;
         }
     });
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

Lamda表达式直接测试：

    @Test
    public  void test6(){
     List list=filterEmployee(employeeList,(e)->e.getSalary()<=5000);
     list.forEach(System.out::println);
    }

通过比较Lamda表达式是代码量最小的一种代码，无论是Lamda表达式还是匿名内部类他们都是建立在策略模式之上的一种方法，简化了实现类的操作。

2.什么情况下可以使用Lamda表达式

只有是函数式接口才支持Lamda表达式，函数式接口是接口中只有一个方法，使用注解@FunctionInterface做解释。

3.Lamda表达式结构

   左侧是参数列表，右侧是方法的具体实现；一个参数省去括号，多条函数体用{}

【总结】

其实Lamda表达式非常容易学习，使用的前提是函数式接口，表达式的左侧是参数列表，右侧是接口方法的具体实现。它简化了代码，让代码更加美化！