Java8 Lambda表达式(一)

时间:2021-05-18 20:03:36

一、应用场景引入

首先编写对应的实体类模拟实际业务:

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Employee {
private String name;
private Integer age;
private double salary;
}

具体数据:

List<Employee> employees = Arrays.asList(
new Employee("张三", 18, 6999.9, Employee.Status.FREE),
new Employee("李四", 38, 3999.9, Employee.Status.BUSY),
new Employee("王五", 50, 5999.9, Employee.Status.VOCATION),
new Employee("赵六", 19, 2999.9, Employee.Status.FREE),
new Employee("田七", 18, 4999.9, Employee.Status.BUSY)
);

此时我们需要得到年龄>=35的所有员工,则可以:

public List<Employee> filterEmployees(List<Employee> employees) {
List<Employee> res = new ArrayList<>();
for (Employee employee : employees) {
if (employee.getAge()>=35){
res.add(employee);
}
}
return res;
} @Test
public void t3() {
List<Employee> res = filterEmployees(employees);
for (Employee employee : res) {
System.out.println(employee);
}
}

但这样可扩展性不好,当我们需要更改过滤条件时则需要新写一个过滤函数,其中有很多相同的代码。

优化一:使用策略模式

先编写一个过滤策略接口:

public interface MyPredicate<t> {
boolean condition(T t);
}

对应的用于过滤年龄的实现类FilterEmployeeByAge

public class FilterEmployeeByAge implements MyPredicate<Employee> {
@Override
public boolean condition(Employee employee) {
return employee.getAge() >= 35;
}
}

然后再编写根据策略进行过滤的函数:

public List<employee> filterEmployees(List<Employee> employees, MyPredicate<Employee> predicate) {
List<Employee> res = new ArrayList<>();
for (Employee employee : employees) {
if (predicate.condition(employee)){
res.add(employee);
}
}
return res;
}

这样我们即可根据不同的策略进行过滤了,如此时我们希望得到年龄>=35的所有员工:

// 策略模式
@Test
public void t4() {
List<Employee> employees = filterEmployees(this.employees, new FilterEmployeeByAge());
for (Employee employee : employees) {
System.out.println(employee);
}
}

若我们希望进行扩展,此时希望得到工资>=3000的所有员工,则可以再编写一个策略实现类,然后再进行相应的策略选择:

// FilterEmployeeBySalary.java
public class FilterEmployeeBySalary implements MyPredicate<Employee> {
@Override
public boolean condition(Employee employee) {
return employee.getSalary() >= 3000;
}
} // MyTest.java
@Test
public void t5() {
List<Employee> employees = filterEmployees(this.employees, new FilterEmployeeBySalary());
for (Employee employee : employees) {
System.out.println(employee);
}
}

但通过这种方法还是比较麻烦,每定义一种过滤条件都需要新建一个类,这时我们可以进一步优化。

优化二:使用匿名内部类

// 匿名内部类
@Test
public void t6() {
List<Employee> employees = filterEmployees(this.employees, new MyPredicate<Employee>() {
@Override
public boolean condition(Employee employee) {
return employee.getAge() > 40;
}
});
for (Employee employee : employees) {
System.out.println(employee);
}
}

这时,我们需要什么样的条件只需要在匿名内部类中进行编写即可,不需要编写新的类,但匿名内部类的形式还是显得不够简洁,可读性不够高。

优化三:使用Lambda表达式

// lambda表达式
@Test
public void t7() {
List<Employee> employees = filterEmployees(this.employees, employee -> employee.getAge() > 30);
employees.forEach(System.out::println);
}

可以看到代码简洁了很多,而且可读性也变高了。

优化四:使用Stream API

在上一步优化中,我们仍需手动定义过滤使用的接口和自定义的过滤函数,那么JDK中有没有直接可以“拿来”的工局呢?Stream API就是JDK中提供的专门用来进行过滤操作的工具,使用方式如下:

// Stream API
@Test
public void t8() {
employees.stream()
.filter(employee -> employee.getSalary() >= 3000)
.forEach(System.out::println);
System.out.println("---------------");
// 得到其中所有的字段
employees.stream()
.map(Employee::getName)
.forEach(System.out::println);
}

运行结果:

Employee(name=李四, age=38, salary=3999.9)
Employee(name=王五, age=50, salary=5999.9)
Employee(name=田七, age=16, salary=4999.9)
---------------
张三
李四
王五
赵六
田七

二、Lambda运算符和对应语法

Java8 Lambda表达式(一)

语法格式

语法格式一:无参数,无返回值

() -> System.out.println("hello world");

@Test
public void t1() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello world");
}
};
r.run();
System.out.println("-------------------------");
Runnable r1 = () -> System.out.println("Hello Lambda");
r1.run();
}

语法格式二:有一个参数,而且无返回值

(x) -> System.out.println(x);

@Test
public void t2() {
Consumer<String> con = (s) -> System.out.println(s);
con.accept("我大尚硅谷威武");
}

语法格式三:若只有一个参数,小括号可以省略不写

x -> System.out.println(x);

语法格式四:有两个以上的参数,有返回值,且Lambda体中有多条语句

Comparator<Integer> comparator1 = (o1, o2) -> {
System.out.println("函数式接口");
return Integer.compare(o1, o2);
};
@Test
public void t3() {
// 使用匿名内部类
Comparator<Integer> comparator = new Comparator<integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};
// 使用Lambda表达式
Comparator<Integer> comparator1 = (o1, o2) -> {
System.out.println("函数式接口");
return Integer.compare(o1, o2);
};
}

语法格式五:若Lambda体中只有一条语句,return和大括号都可以省略

Comparator<Integer> comparator = (o1, o2) -> o1 - o2;

@Test
public void t4() {
Comparator<Integer> comparator = (o1, o2) -> o1 - o2;
int compare = comparator.compare(6, 2);
System.out.println(compare);
}

语法格式六:Lambda表达式的参数列表的数据类型可以省略不写,原:

Comparator<Integer> comparator = (Integer o1, Integer o2) -> o1 - o2;

口诀:

左右遇一括号省

左侧类型推断省

Lambda表达式需要“函数式接口”的支持

函数式接口:接口中只有一个抽象方法的接口,可以使用注解@FunctionalInterface进行修饰

三、简单应用

1.调用Collections.sort() 方法,通过定制排序比较两个Employee (先按年龄比,年龄相同按Salary比),使用Lambda作为参数传递。

准备数据:

List<Employee> employees = Arrays.asList(
new Employee("张三", 18, 6999.9),
new Employee("李四", 38, 3999.9),
new Employee("王五", 50, 5999.9),
new Employee("赵六", 19, 2999.9),
new Employee("田七", 18, 4999.9)
);

客户端:

@Test
public void t1() {
employees.sort((o1, o2) -> {
if (o1.getAge() != o2.getAge()) {
return Integer.compare(o1.getAge(), o2.getAge());
} else {
return Double.compare(o1.getSalary(), o2.getSalary());
}
});
employees.forEach(System.out::println);
}

2.①声明函数式接口,接口中声明抽象方法,public String getValue(String str);

②声明类TestLambda ,类中编写方法使用接口作为参数,将一个字符串转换成大写,

并作为方法的返回值。

函数式接口

@FunctionalInterface
public interface MyFunction {
public String getValue(String str);
}

客户端:

public String strHandler(String str, MyFunction mf) {
return mf.getValue(str);
} @Test
public void test2() {
String res = strHandler("abcdefg", str -> str.toUpperCase());
System.out.println(res);
}

3.①声明一个带两个泛型的函数式接口,泛型类型为<t,r> T为参数,R为返回值

②接口中声明对应抽象方法。

③在TestLambda 类中声明方法,使用接口作为参数,计算两个long 型参数的和。

④再计算两个long 型参数的乘积。

函数式接口

@FunctionalInterface
public interface MyFunction2<T> {
public R getValue(T t1, T t2);
}

客户端:

public void op(Long l1, Long l2, MyFunction2<Long, Long> mf) {
System.out.println(mf.getValue(l1, l2));
} @Test
public void t3() {
op(100L, 200L, (t1, t2) -> t1 + t2);
op(100L, 200L, (t1, t2) -> t1 * t2);
}

下一步:Java8 Lambda表达式(二)