一篇文章带你了解jdk1.8新特性

一篇文章带你了解jdk1.8新特性

目录一、为什么使用Lambda表达式二、匿名内部类的方式与Lambda表达式方式的比较（示例）三、需求演示示例一、创建一个员工实体类二、普通方式实现1、代码如下2、运行main函数，输出结果如下图：3、 普通方式实现的缺点三、优化方式一（策略模式实现）1、定义一个策略接口2、定义一个过滤年龄的接口实现类3、定义一个过滤薪资的接口实现类4、测试类如下：5、运行main函数，输出如下:6、 策略模式实现的缺点四、优化方式二（匿名内部类实现）1、定义一个策略接口2、测试类如下：3、运行main函数，输出如下:五、优化方式三（Lambda实现）1、定义一个策略接口2、测试类如下：3、运行main函数，输出如下:六、优化方式四（Stream API和Lambda表达式实现）1、代码如下：2、运行main函数，输出结果如下：四、示例演示总结总结

一、为什么使用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 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 list = filterEmployeeAge(emps);

for (Employee employee : list) {

System.out.println(employee);

}

System.out.println("============================");

//调用工资大于5000的员工信息方法

List list1 = filterEmployeeSalary(emps);

for (Employee employee : list1) {

System.out.println(employee);

}

}

/**

* 获取公司中年龄小于 35 的员工信息

* @param emps

* @return

*/

public static List filterEmployeeAge(List emps){

List list = new ArrayList<>();

for (Employee emp : emps) {

if(emp.getAge() <= 35){

list.add(emp);

}

}

return list;

}

/**

* 获取公司中工资大于 5000 的员工信息

* @param emps

* @return

*/

public static List filterEmployeeSalary(List emps){

List 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 {

//该方法默认为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{

@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{

@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 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 list = getEmployee(emps,new FilterEmployeeAge());

for (Employee employee : list) {

System.out.println(employee);

}

System.out.println("------------------------");

//调用调用工资大于5000的员工信息方法

List list1 = getEmployee(emps,new FilterEmployeeSalary());

for (Employee employee : list1) {

System.out.println(employee);

}

}

/**

* @param list 需要传入员工信息

* @param strategy 需要传入具体策略

*/

public static List getEmployee(List list,MyStrategy strategy){

List 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 {

//该方法默认为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 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 list = getEmployee(emps, new MyStrategy(){

@Override

public boolean getEmployeeInfo(Employee employee) {

return employee.getAge() <= 35;

}

});

for (Employee employee : list) {

System.out.println(employee);

}

System.out.println("------------------------");

//调用调用工资大于5000的员工信息方法(匿名内部类的方式)

List list1 = getEmployee(emps, new MyStrategy(){

@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 getEmployee(List list, MyStrategy strategy){

List 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 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)

HxLflS );

//调用年龄小于35的员工信息方法(Lambda表达式实现)

List list = getEmployee(emps, (e) -> e.getAge() <= 35);

for (Employee employee : list) {

System.out.println(employee);

}

System.out.println("------------------------");

//调用调用工资大于5000的员工信息方法(Lambda表达式实现)

List list1 = getEmployee(emps, (e) -> e.getSalary() >= 5000);

for (Employee employee : list1) {

System.out.println(employee);

}

}

/**

* 获取条件过滤后的员工信息

* @param list 需要传入员工信息

* @param strategy 需要传入具体策略

*/

public static List getEmployee(List list, MyStrategy strategy){

List 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 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表达式可以传递的代码（将代码像数据一样进行传递）并且可以写出更简洁、更灵活的代码。

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。