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

版权声明:欢迎访问,本文为小编原创文章 https://blog.csdn.net/changyinling520/article/details/80567437

【前言】

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

【内容】

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

从案例中我们找出答案:
例如从员工中分别找出工资小于5000的员工,找出年龄大于35的员工;

//员工的集合:
  List<Employee> 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<Employee> filterEmployeesByAge(List<Employee> list){
        List<Employee> emps=new ArrayList<>();
        for (Employee emp : list) {
            if(emp.getAge()>=35) {
                emps.add(emp);
            }
        }
        return emps;
    }

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

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

    }

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

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

1.创建比较接口

package com.cyl.Lamda;

/**
 * Created by cyl on 2018/6/4.
 */
public interface MyPredicate<T> {
     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<Employee>  filterEmployee(List<Employee> list,MyPredicate<Employee> mp){
      List<Employee> 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<Employee> list= filterEmployee(employeeList, new MyPredicate<Employee>() {
         @Override
         public boolean test(Employee employee) {
             return employee.getSalary()<=5000;
         }
     });
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

Lamda表达式直接测试:

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

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

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

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

3.Lamda表达式结构

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

【总结】

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

展开阅读全文

没有更多推荐了,返回首页