jdk1.8为什么使用lambda表达式

本篇内容主要讲解“jdk1.8为什么使用lambda表达式”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“jdk1.8为什么使用lambda表达式”吧!

目录

• 一、为什么使用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<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函数，输出结果如下：

到此，相信大家对“jdk1.8为什么使用lambda表达式”有了更深的了解，不妨来实际操作一番吧！这里是亿速云网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！