一、lambda表达式的格式：
例：（x, y）-> { };
- 左侧：lambda 表达式的参数列表
- 中间：lambda 表达式的操作符
- 右侧：lambda 表达式执行的功能（lambda 体）
二、lambda 表达式的支持：
- 必须是“函数式接口”才支持lambda表达式
- 函数式接口（functional interface）：只有一个抽象方法的接口，@FunctionalInterface注解可以检查接口是否是函数是接口
三、java 四大内置核心函数式接口：
- Consumer
:消费型接口 void accept(T t); - Supplier
:供给型接口 T get(); - Function
- Predicate
:断言型接口 boolean test(T t);
四、使用 lambda 表达式需注意：（能省则省）
- 1.参数列表只有一个参数时，()可以不写。
- 2.参数列表的参数类型要么全写，要么不写（JVM通过上下文可以推断出数据类型，即类型推断）。
- 3.lambda 体中有多条语句，必须用{}。
- 4.lambda 体中只有一条语句，且有返回值，return 和 {} 都不写。
- 5.lambda 表达式就相当于匿名内部类。
五、下面看具体示例：（建议看完示例，再回味一下上面的四点）
目录结构：
目录结构.png
实在看不懂可以自己写个 Demo 体会一下，全部代码和运行结果如下：
PersonService1.java
package com.wl.service;
@FunctionalInterface
public interface PersonService1 {
// 无参数，无返回值接口
void show();
}
PersonService2.java
package com.wl.service;
import com.wl.model.Person;
public interface PersonService2 {
//有一个参数，无返回值接口
void show(Person person);
}
PersonService3.java
package com.wl.service;
public interface PersonService3 {
//有三个参数，无返回值接口
void show(String name, Integer age, String gender);
}
PersonService4.java
package com.wl.service;
import com.wl.model.Person;
public interface PersonService4 {
// 有一个参数，有返回值接口
Person show(Person person);
}
Person.java
package com.wl.model;
public class Person {
private String name;
private Integer age;
private String gender;
public Person() {
}
public Person(String name, Integer age, String gender) {
super();
this.name = name;
this.age = age;
this.gender = gender;
}
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 String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
}
}
Demo.java
package com.wl.demo;
import com.wl.model.Person;
import com.wl.service.*;
public class Demo {
public static void main(String[] args) {
System.out.println("test1()运行结果:");
test1(); // PersonService1
System.out.println();
System.out.println("test2()运行结果:");
test2(); // PersonService2
System.out.println();
System.out.println("test3()运行结果:");
test3(); // PersonService3
System.out.println();
System.out.println("test4()运行结果:");
test4(); // PersonService4
}
/**
* 无参数，无返回值
* () -> System.out.println(111);
*/
public static void test1() {
PersonService1 personService11 = () -> System.out.println(111);
personService11.show();
// 等同于
PersonService1 personService12 = new PersonService1() {
@Override
public void show() {
System.out.println(222);
}
};
personService12.show();
}
/**
* 一个参数，无返回值，一个参数时，()可以不写
* (x) -> System.out.println(x);
*/
public static void test2() {
PersonService2 personService21 = x -> System.out.println(x);
personService21.show(new Person("Bob", 21, "男"));
// 等同于
PersonService2 personService22 = new PersonService2() {
@Override
public void show(Person person) {
System.out.println(person);
}
};
personService22.show(new Person("aaa", 20, "女"));
}
/**
* 多个参数，无返回值 多条语句，要加{}
* (x, y, z) -> {
Person person = new Person(x, y, z);
System.out.println(person);
};
*/
public static void test3() {
PersonService3 personService31 = (x, y, z) -> {
Person person = new Person(x, y, z);
System.out.println(person);
};
personService31.show("Tom", 30, "男");
// 等同于
PersonService3 personService32 = new PersonService3() {
@Override
public void show(String name, Integer age, String gender) {
Person person = new Person(name, age, gender);
System.out.println(person);
}
};
personService32.show("bbb", 23, "女");
}
/**
* 一个参数，有返回值
* x -> x
*/
public static void test4() {
PersonService4 personService41 = x -> x;
Person person1 = personService41.show(new Person("Scott", 25, "男"));
System.out.println(person1);
PersonService4 personService42 = new PersonService4() {
@Override
public Person show(Person person) {
return person;
}
};
Person person2 = personService42.show(new Person("ccc", 27, "女"));
System.out.println(person2);
}
}
运行结果：
运行结果.png