一篇文章带你了解jdk1.8新特性--为什么使用lambda表达式
更新时间：2021年08月25日 09:46:49 作者：小志的博客
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，本篇文章就带你了解，希望能给你带来帮助
一、为什么使用Lambda表达式
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使java的语言表达能力得到了提升。
二、匿名内部类的方式与Lambda表达式方式的比较（示例）
场景：比较2个数，一种采用内部类的方式，一种采用lambda表达式的方式；如下图：
三、需求演示示例
场景演示：获取员工年龄小于35的员工信息，然后再获取员工工资大于5000的员工信息。
一、创建一个员工实体类
package com.xz.springboot_java8.day1.entity;
/**
* @description:
* @author: xz
* @create: 2021-08-23 21:07
*/
public class Employee {
private int id;//id
private String name;//名称
private int age;//年龄
private Double salary; //薪水
//无参构造方法
public Employee() { }
//带参构造方法
public Employee(int id, String name, int age, Double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
//getter、setter、及toString方法此处省略
........
}
二、普通方式实现
1、代码如下
package com.xz.springboot_java8.day1.test;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @description:普通方式实现
* 员工年龄小于35的员工信息和员工工资大于5000的员工信息。
*
* @author: xz
* @create: 2021-08-23 21:10
*/
public class Test1 {
public static void main(String[] args) {
//初始化员工数据并转成list
List<Employee> emps = Arrays.asList(
new Employee(1, "张三", 18, 2222.22),
new Employee(2, "李四", 25, 3333.33),
new Employee(3, "王五", 38, 5555.55),
new Employee(4, "赵六", 45, 8888.88)
);
//调用年龄小于35的员工信息方法
List<Employee> list = filterEmployeeAge(emps);
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("============================");
//调用工资大于5000的员工信息方法
List<Employee> list1 = filterEmployeeSalary(emps);
for (Employee employee : list1) {
System.out.println(employee);
}
}
/**
* 获取公司中年龄小于 35 的员工信息
* @param emps
* @return
*/
public static List<Employee> filterEmployeeAge(List<Employee> emps){
List<Employee> list = new ArrayList<>();
for (Employee emp : emps) {
if(emp.getAge() <= 35){
list.add(emp);
}
}
return list;
}
/**
* 获取公司中工资大于 5000 的员工信息
* @param emps
* @return
*/
public static List<Employee> filterEmployeeSalary(List<Employee> emps){
List<Employee> list = new ArrayList<>();
for (Employee emp : emps) {
if(emp.getSalary() >= 5000){
list.add(emp);
}
}
return list;
}
}
2、运行main函数，输出结果如下图：
3、 普通方式实现的缺点
每新增一个新的需求就要重新写一个方法，方法中只有判断逻辑部分不同，其他都相同，出现代码冗余。如下图：
三、优化方式一（策略模式实现）
1、定义一个策略接口
package com.xz.springboot_java8.day1.test2;
/**
* 定义一个策略接口
*/
public interface MyStrategy<T> {
//该方法默认为public abstract修饰
public abstract boolean getEmployeeInfo(T t);
}
2、定义一个过滤年龄的接口实现类
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
/**
* @description: 定义一个过滤年龄的接口实现类
* @author: xz
* @create: 2021-08-23 21:24
*/
public class FilterEmployeeAge implements MyStrategy<Employee>{
@Override
public boolean getEmployeeInfo(Employee employee) {
return employee.getAge() <= 35;
}
}
3、定义一个过滤薪资的接口实现类
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
/**
* @description: 定义一个过滤薪资的接口实现类
* @author: xz
* @create: 2021-08-23 21:35
*/
public class FilterEmployeeSalary implements MyStrategy<Employee>{
@Override
public boolean getEmployeeInfo(Employee employee) {
return employee.getSalary() >= 5000;
}
}
4、测试类如下：
package com.xz.springboot_java8.day1.test2;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.*;
/**
* @description: 策略模式实现
* 员工年龄小于35的员工信息和员工工资大于5000的员工信息。
* @author: xz
* @create: 2021-08-23 11:21
*/
public class test {
public static void main(String[] args) {
//初始化员工数据并转成list
List<Employee> emps = Arrays.asList(
new Employee(1, "张三", 18, 2222.22),
new Employee(2, "李四", 25, 3333.33),
new Employee(3, "王五", 38, 5555.55),
new Employee(4, "赵六", 45, 8888.88)
);
//调用年龄小于35的员工信息方法
List<Employee> list = getEmployee(emps,new FilterEmployeeAge());
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("------------------------");
//调用调用工资大于5000的员工信息方法
List<Employee> list1 = getEmployee(emps,new FilterEmployeeSalary());
for (Employee employee : list1) {
System.out.println(employee);
}
}
/**
* @param list 需要传入员工信息
* @param strategy 需要传入具体策略
*/
public static List<Employee> getEmployee(List<Employee> list,MyStrategy<Employee> strategy){
List<Employee> empList = new ArrayList<>();
for(Employee emp:list){
if(strategy.getEmployeeInfo(emp)){
empList.add(emp);
}
}
return empList;
}
}
5、运行main函数，输出如下:
6、 策略模式实现的缺点
每新增一个新的需求就要重新写一个实现策略接口的实现类，类图如下:
四、优化方式二（匿名内部类实现）
1、定义一个策略接口
package com.xz.springboot_java8.day1.test2;
/**
* 定义一个策略接口
*/
public interface MyStrategy<T> {
//该方法默认为public abstract修饰
public abstract boolean getEmployeeInfo(T t);
}
2、测试类如下：
package com.xz.springboot_java8.day1.test3;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @description: 匿名内部类实现
* 员工年龄小于35的员工信息和员工工资大于5000的员工信息。
* @author: xz
* @create: 2021-08-23 21:58
*/
public class Test {
public static void main(String[] args) {
//初始化员工数据并转成list
List<Employee> emps = Arrays.asList(
new Employee(1, "张三", 18, 2222.22),
new Employee(2, "李四", 25, 3333.33),
new Employee(3, "王五", 38, 5555.55),
new Employee(4, "赵六", 45, 8888.88)
);
//调用年龄小于35的员工信息方法(匿名内部类的方式)
List<Employee> list = getEmployee(emps, new MyStrategy<Employee>(){
@Override
public boolean getEmployeeInfo(Employee employee) {
return employee.getAge() <= 35;
}
});
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("------------------------");
//调用调用工资大于5000的员工信息方法(匿名内部类的方式)
List<Employee> list1 = getEmployee(emps, new MyStrategy<Employee>(){
@Override
public boolean getEmployeeInfo(Employee employee) {
return employee.getSalary() >= 5000;
}
});
for (Employee employee : list1) {
System.out.println(employee);
}
}
/**
* @param list 需要传入员工信息
* @param strategy 需要传入具体策略
*/
public static List<Employee> getEmployee(List<Employee> list, MyStrategy<Employee> strategy){
List<Employee> empList = new ArrayList<>();
for(Employee emp:list){
if(strategy.getEmployeeInfo(emp)){
empList.add(emp);
}
}
return empList;
}
}
3、运行main函数，输出如下:
五、优化方式三（Lambda实现）
1、定义一个策略接口
package com.xz.springboot_java8.day1.test2;
/**
* 定义一个策略接口
*/
public interface MyStrategy<T> {
//该方法默认为public abstract修饰
public abstract boolean getEmployeeInfo(T t);
}
2、测试类如下：
package com.xz.springboot_java8.day1.test4;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* @description: Lambda实现
* 员工年龄小于35的员工信息和员工工资大于5000的员工信息。
* @author: xz
* @create: 2021-08-23 22:10
*/
public class Test {
public static void main(String[] args) {
//初始化员工数据并转成list
List<Employee> emps = Arrays.asList(
new Employee(1, "张三", 18, 2222.22),
new Employee(2, "李四", 25, 3333.33),
new Employee(3, "王五", 38, 5555.55),
new Employee(4, "赵六", 45, 8888.88)
);
//调用年龄小于35的员工信息方法(Lambda表达式实现)
List<Employee> list = getEmployee(emps, (e) -> e.getAge() <= 35);
for (Employee employee : list) {
System.out.println(employee);
}
System.out.println("------------------------");
//调用调用工资大于5000的员工信息方法(Lambda表达式实现)
List<Employee> list1 = getEmployee(emps, (e) -> e.getSalary() >= 5000);
for (Employee employee : list1) {
System.out.println(employee);
}
}
/**
* 获取条件过滤后的员工信息
* @param list 需要传入员工信息
* @param strategy 需要传入具体策略
*/
public static List<Employee> getEmployee(List<Employee> list, MyStrategy<Employee> strategy){
List<Employee> empList = new ArrayList<>();
for(Employee emp:list){
if(strategy.getEmployeeInfo(emp)){
empList.add(emp);
}
}
return empList;
}
}
3、运行main函数，输出如下:
六、优化方式四（Stream API和Lambda表达式实现）
1、代码如下：
package com.xz.springboot_java8.day1.test5;
import com.xz.springboot_java8.day1.entity.Employee;
import java.util.Arrays;
import java.util.List;
/**
* @description:
* 员工年龄小于35的员工信息和员工工资大于5000的员工信息。
* @author: xz
* @create: 2021-08-23 22:18
*/
public class Test {
public static void main(String[] args) {
//初始化员工数据并转成list
List<Employee> emps = Arrays.asList(
new Employee(1, "张三", 18, 2222.22),
new Employee(2, "李四", 25, 3333.33),
new Employee(3, "王五", 38, 5555.55),
new Employee(4, "赵六", 45, 8888.88)
);
//调用年龄小于35的员工信息方法(Lambda表达式实现)
emps.stream()
.filter((e)->e.getAge() <= 35)
.forEach(System.out::println);
System.out.println("=======================");
//调用调用工资大于5000的员工信息方法(Lambda表达式实现)
emps.stream()
.filter((e)->e.getSalary() >= 5000)
.forEach(System.out::println);
}
}
2、运行main函数，输出结果如下：
四、示例演示总结
由以上优化示例可知，lambda表达式可以传递的代码（将代码像数据一样进行传递）并且可以写出更简洁、更灵活的代码。
总结
本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注脚本之家的更多内容！
相关文章
这篇文章主要介绍了Springboot-注解-操作日志的实现方式，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2021-03-03
解决spring boot hibernate 懒加载的问题
这篇文章主要介绍了解决spring boot hibernate 懒加载的问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-10-10
今天给大家整理了如何在MyBatis中实现DataSource,文中有非常详细的代码示例,对正在学习java的小伙伴们很有帮助,需要的朋友可以参考下2021-06-06
ThreadLocal是线程私有的局部变量存储容器，可以理解成每个线程都有自己专属的存储容器，用来存储线程私有变量。ThreadLocal 在日常开发框架中应用广泛，但用不好也会出现各种问题，本文就此讲解一下。2021-05-05
时候我们导入的项目并不是有maven来管理依赖的,而是要手动添加jar包,比较麻烦,本文主要介绍了非maven项目快速转换为maven项目的方法步骤,具有一定的参考价值,感兴趣的可以了解一下2024-01-01
这篇文章主要介绍了java 关键字static详细介绍及如何使用的相关资料,需要的朋友可以参考下2017-03-03
本文给大家分享如何把spring boot项目部署到tomcat容器中，本文给大家介绍的非常详细，需要的朋友参考下2017-04-04
在IDEA中配置tomcat并创建tomcat项目的图文教程
这篇文章主要介绍了在IDEA中配置tomcat并创建tomcat项目的图文教程,需要的朋友可以参考下2020-07-07
本篇文章主要介绍了Spring Cloud Feign简单使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧2018-02-02
这篇文章主要介绍了java中GZIP压缩解压类使用实例的相关资料,需要的朋友可以参考下2017-03-03
最新评论