Lambda

Lambda表达式

Lambda表达式是一个匿名函数, 使用它设计的代码更加简洁, 而且可读, 最重要的是代码量也随之减少.

lambda

首先看一段代码,我们创建一个People类,大致如下

public class People {

   //姓名
    private String name;
    //年龄
    private Integer age;

    public People(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    //Getter and Setter
    //Override toStrng method
}

代码中创建了一个抽象类Filter, 接受一个泛型T, 返回Boolean值

/**
 *自定的过滤器抽象类,
 */
public interface Filter<T> {

    /**
     * 用于判断是否符合规定
     * 
     * @param t 用于接受要筛选的对象
     * @return
     */
    public Boolean adult(T t);
}

此处接收一个People集合,以及一个Fileter过滤器,然后返回符合条件的集合

	/**
     * 用于筛选符合招聘条件的人,放入集合中并返回
     *
     * @param list 未筛选前人员集合
     * @param filter 过滤器
     * @return List<People> 符合条件的人
     */
    public static List<People> recruitment(List<People> list, Filter<People> filter){

        List<People> conformList = new ArrayList<People>();
        for(People people : list){
            if(filter.adult(people)){
                conformList.add(people);
            }
        }
        return conformList;
    }

在不使用Lambda表达式的代码中我们可以使用匿名内部类作为入参,来调用Filter方法

	List<People> recruitment = recruitment(list, new Filter<People>() {
           public Boolean adult(People people) {
               return people.getAge() >= 18 ? true : false;
           }
     });

下面是使用了Lambad表达式的写法

List<People> recruitment = recruitment(list, people -> people.getAge() >= 18 ? true : false);

这里可以看到,使用了Lambda使得代码变得更加的简洁

lambda语法

箭头操作符左侧为lambda表达式的参数列表,对应匿名实现类中方法的参数列表people

public Boolean adult(People people)

右侧是抽象类中的方法实现,对应的是匿名实现类中的具体实现方法

return people.getAge() >= 18 ? true : false;

所以 lambda箭头函数必须和接口中唯一的抽象方法保持一致(参数和返回值完全相同)，正因为如此，lambda中会对参数类型进行类型推断， 我们只写了一个people, java就知道这是一个People对象

语法有如下几种格式：

• 无参数无返回值：

() -> 实现方法

• 有一个参数无返回值：

(x) -> 实现方法
//如果只有一个参数括号可以省略,如下
x -> 实现方法

• 有多个参数，有返回值，并且实现方法中有多条语句：

(x,y) -> {实现方法}

注：若方法体只有一条语句，那么大括号和return都可以省略, lambda表达式的参数列表的参数类型可以省略不写，可以进行类型推断。

练习

使用Lambda实现两个数的加减乘除运算

创建一个函数式接口,使用@FunctionalInterface注解

@FunctionalInterface
public interface Calculation {

    public int calculate(int num1, int num2);
}

创建一个caluate方法,接受三个参数,分别是用于计算的两个数,以及抽象类calculation,然后使用Lambda表达式实现抽象接口

public class Practice {

    public static void main(String[] args){

        int add = caluate(2, 1, (num1, num2) -> num1 + num2);
        System.out.println(add);
        int less = caluate(2, 1, (num1, num2) -> num1 - num2);
        System.out.println(less);
        int except = caluate(2, 1, (num1, num2) -> num1 / num2);
        System.out.println(except);
        int multiply = caluate(2, 1, (num1, num2) -> num1 * num2);
        System.out.println(multiply);
    }
    public static int caluate(int num1, int num2, Calculation calculation){
        return calculation.calculate(num1, num2);
    }
}