lambda表达式

lambda表达式，只能实现函数式接口。

函数式接口

基础概念

如果说， 一个接口中， 要求实现类必须实现的抽象方法， 有且只有一个！ 这样的接口， 就

是函数式接口。

interface Test1 {

void test();

}

@FunctionalInterface

是一个注解， 用在接口之前， 判断这个接口是否是一个函数式接口。 如果是函数式接口，

没有任何问题。 如果不是函数式接口， 则会报错。 功能类似于 @Override。

lambda表达式的基础语法：

（参数） -> {

方法体

}；

参数部分 ： 方法的参数列表， 要求和实现的接口中的方法参数部分一致， 包括参数的数量

和类型。

方法体部分 ： 方法的实现部分， 如果接口中定义的方法有返回值， 则在实现的时候， 注意

返回值的返回

-> : 分隔参数部分和方法体部分。

// 1. 无参、无返回值的方法实现

NoneReturnNoneParameter lambda1 = () -> {

System.out.println("无参、无返回值方法的实现");

};

lambda1.test();

// 2. 有参、无返回值的方法实现

NoneReturnSingleParameter lambda2 = (int a) -> {

System.out.println("一个参数、无返回值方法的实现: 参数是 " + a);

};

lambda2.test(10);

// 3. 多个参数、无返回值方法的实现

NoneReturnMutipleParameter lambda3 = (int a, int b) -> {

System.out.println("多个参数、无返回值方法的实现: 参数a是 " + a +

", 参数b是 " + b);

};

lambda3.test(10, 20);

参数部分的精简

lambda表达式中的参数的类型可以省略不写

必须要保证参数的数量和类型需要和接口中的方法保持一

致

如果需要省略参数的类型， 要保证： 要省略， 每一个参数的类型都必须省略不

写。 绝对不能出现， 有的参数类型省略了， 有的参数类型没有省略。

// 多个参数、无返回值的方法实现

NoneReturnMutipleParameter lambda1 = (a, b) -> {

System.out.println("多个参数、无返回值方法的实现: 参数a是 " + a +

", 参数b是 " + b);

};

参数的小括号

如果方法的参数列表中的参数数量 有且只有一个 ，此时，参数列表的小括号是可以

省略不写的。

注意事项:

只有当参数的数量是一个的时候， 多了、少了都不能省略。

省略掉小括号的同时， 必须要省略参数的类型。

// 有参、无返回值的方法实现

NoneReturnSingleParameter lambda2 = a -> {

System.out.println("一个参数、无返回值方法的实现: 参数是 " + a);

};

方法体大括号的精简

当一个方法体中的逻辑， 有且只有一句的情况下， 大括号可以省略。

// 有参、无返回值的方法实现

NoneReturnSingleParameter lambda2 = a -> System.out.println("一个参

数、无返回值方法的实现: 参数是 " + a);

return的精简

如果一个方法中唯一的一条语句是一个返回语句， 此时在省略掉大括号的同时， 也

必须省略掉return。

(a, b) -> a + b;

静态方法的引用

语法：

类::静态方法

注意事项:

在引用的方法后面， 不要添加小括号。

引用的这个方法， 参数（数量、类型） 和 返回值， 必须要跟接口中定义的一致。

interface SingleReturnMutipleParameter{

void test(int a,int b);

}

SingleReturnMutipleParameter lambda11 = (a,b)->

Calculator.calculate(a,b);

//简化后

SingleReturnMutipleParameter lambda1 =

Calculator::calculate;

System.out.println(lambda1.test(10, 20));

}

public static int calculate(int a, int b) {

// 稍微复杂的逻辑：计算a和b的差值的绝对值

if (a > b) {

return a - b;

}

return b - a;

}

}

 

 

实际上就是用函数接口实例化了一个子类的对象，直接用接口名.抽象方法名

 

 

 

非静态方法的引用

语法：

对象::非静态方法

注意事项:

在引用的方法后面， 不要添加小括号。

引用的这个方法， 参数（数量、类型） 和 返回值， 必须要跟接口中定义的一致。

示例:

interface SingleReturnMutipleParameter{

void test(int a,int b);

}

SingleReturnMutipleParameter1 lambda1 = (a,b)->new

Calculator().calculate(a,b);

//简化

SingleReturnMutipleParameter lambda = new

Calculator()::calculate;

System.out.println(lambda.test(10, 30));

SingleReturnMutipleParameter1 lambda1 = (a,b)->new

Calculator().calculate(a,b);

//简化

SingleReturnMutipleParameter lambda = new

Calculator()::calculate;

System.out.println(lambda.test(10, 30));

 

接口实例化子类对象，在子类对象中new了一个计算的类，匿名内部类调用

 

构造方法的引用

使用场景

如果某一个函数式接口中定义的方法， 仅仅是为了得到一个类的对象。 此时我们就

可以使用构造方法的引用， 简化这个方法的实现。

语法

类名::new

注意事项

可以通过接口中的方法的参数， 区分引用不同的构造方法。

// lambda表达式实现接口

GetPerson lambda = Person::new; // 引用到Person类中的无

参构造方法，获取到一个Person对象

Person person = lambda.test();

GetPersonWithParameter lambda2 = Person::new; // 引用到

Person类中的有参构造方法，获取到一个Person对象

lambda2.test("xiaoming", 1);

 

用自定义类的类名通过new的方式获取构造方法，将构造方法赋给接口，通过该接口来实例化对象

// 如果对于这个方法的实现逻辑，是为了获取到对象的名字

GetField field = person -> person.getName();

// 对于对象方法的特殊引用

GetField field = Person::getName;

// 如果对于这个方法的实现逻辑，是为了给对象的某些属性进行赋值

SetField lambda = (person, name) -> person.setName(name);

SetField lambda = Person::setName;

// 如果对于这个方法的实现逻辑，正好是参数对象的某一个方法

ShowTest lambda2 = person -> person.show();

ShowTest lambda2 = Person::show;

interface ShowTest {

void test(Person person);

}

interface SetField {

void set(Person person, String name);

}

interface GetField {

String get(Person person);

}

线程的实例化

Thread thread = new Thread(() -> {

// 线程中的处理

});

集合的常见方法

// 按照条件进行删除

list.removeIf(ele -> ele.endsWith(".m"));

// 批量替换

list.replaceAll(ele -> ele.concat("!"));

// 自定义排序

list.sort((e1, e2) -> e2.compareTo(e1));

// 遍历

list.forEach(System.out::println);

集合的流式编程

list.parallelStream().filter(ele -> ele.length() >

2).forEach(System.out::println);