1、基础语法
-> :箭头操作符/lambda操作符
" -> " 将lambda表达式拆分成左右两部分
- 左侧为参数列表。
- 右侧为所需要执行的内容:lambda体(接口的实现方法)。
- 接口:函数式接口。只存在一个抽象方法的接口。
函数式接口:可通过@FunctionalInterface进行修饰,当接口非函数式接口时,函数会编译错误、
2、场景
2.1 无参数无返回值的接口
无参数无返回值写法:左侧空括号,右侧实现
() -> System.out.println()
/**
* 无参数无返回值写法:左侧空括号,右侧实现
* () -> System.out.println()
*/
@Test
public void test1(){
/**
* jdk1.7之前,匿名内部类引用的数据必须为final
* 1.8可以不声明,但本质上还是final
*/
int i = 0;
//案例
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello"+i);
}
};
runnable.run();
System.out.println("===========================");
/**
* lambda实现
*/
Runnable runnable1 = ()-> System.out.println("hello world"+i);
runnable1.run();
}
2.2 一个参数无返回值写法
左侧为参数(随便命名),右侧为实现
参数小括号可以省略
/**
* 有一参数无返回值写法
*/
@Test
public void test2(){
Consumer<String> consumer = (x) -> System.out.println(x);
consumer.accept("superMan");
}
/**
* 有一个参数,参数小括号可以省略
*/
@Test
public void test3(){
Consumer<String> consumer = x -> System.out.println(x);
consumer.accept("superMan");
}
2.3 多参多返回值多语句写法
参数加括号
语句用大括号包裹
只有一条语句时,大括号可省略
当大括号省略时,return关键字也必须省略
/**
* 有多个参数,有返回值,且存在多条语句
*/
@Test
public void test4() {
Comparator<Integer> com = (x, y) -> {
System.out.println("多条语句");
return Integer.compare(x, y);
};
int compare = com.compare(1, 2);
System.out.println(compare);
}
/**
* 有多个参数,有返回值,存在1条语句
*/
@Test
public void test5() {
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
int compare = com.compare(1, 2);
System.out.println(compare);
}
注:
参数数据类型可以不写,JVM可通过上下文推断出数据类型
但为一个参数增加数据类型时,所用的数据类型都需要指定数据类型
3、实践
接下来,我们通过一个需求来学习lambda表达式:
员工有姓名、年龄和工资三个属性,我们要在员工列表中找出薪资>5000的员工信息。
员工实体类:
public class Employee {
private String name;
private int age;
private double salary;
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
}
接口:
@FunctionalInterface
public interface MyInterface<T> {
public boolean test(T t);
}
实现:
public class FilterEmployeeBySalary implements MyInterface<Employee>{
@Override
public boolean test(Employee employee) {
return employee.getSalary()>5000;
}
}
整合成lambda表达式:
public class TestLambda {
List<Employee> employees = Arrays.asList(
new Employee("张三",18,999),
new Employee("李四",183,9999),
new Employee("钱五",185,9999),
new Employee("宋六",184,9999),
new Employee("孙七",183,9999),
new Employee("王八",128,999)
);
public List<Employee> returnSJMS(List<Employee> list, MyInterface<Employee> employeeMyInterface){
ArrayList<Employee> arrayList = new ArrayList<>();
for (Employee employee : list) {
if (employeeMyInterface.test(employee)){
arrayList.add(employee);
}
}
return arrayList;
}
@Test
public void test6(){
List<Employee> employees = returnSJMS(this.employees, (employee) -> employee.getSalary() < 5000);
for (Employee employee : employees) {
System.out.println(employee);
}
}
}