java8-02-再探Lambda表达式

Lambda表达式   主要作用替代匿名内部类   达到简化代码的操作

 

                            

 

 

 

 

 

Lambda表达式 在对象中的使用

 

Employee类

 

 

 

 

需求1:得到年龄大于18的员工信息

 

定义方法

测试类

结果

 

 

 

需求2:得到薪水大于10000的员工信息

 

定义方法

测试类

 

结果

 

总结以上方法 代码重复较多  

 

开始优化  使用Lambda表达式   +   函数式接口

 

1.自定义一个函数式接口 

 

作用 模仿 java8中Predicate 函数式接口

该接口定义一个泛型 返回布尔值

 

 

2.定义一个公用方法  (两个需求的方法都能调用)

 

 自定义函数式接口 MyPredicate 泛型放入Employee

(作用是后面使用Lambda表达式,更加说明了Lambda表达式使用依赖函数式接口)

 

 

3.test01   test02  调用公用方法  使用匿名内部类

 

    传入 准备的数据 list   new 函数式接口

    在匿名内部类的方法中  实现各自需求  (age>18    salary>10000)

 

 

 

结果

 

 

3.使用Lambda表达式

    替代匿名内部类

 

 

具体替换内容     test01  与 test 04 替换相同

 

test02 与 test03替换内容   Lamdba表达式 替换 匿名内部类 

 

 

package com.wf.zhang.java8.lamdba;

public class Employee {

    private String name;

    private int age;

    private double salary;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee() {

    }

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

package com.wf.zhang.java8.lamdba;

@FunctionalInterface
public interface MyPredicate<T> {

    public  boolean test(T t);
}

package com.wf.zhang.java8.lamdba;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class TestLambda3 {

    @Test
    public void test() {

        //匿名内部类写法
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };


        //使用Lambda写法
        Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);


    }


    //准备数据
    List<Employee> list = Arrays.asList(
            new Employee("张飞", 18, 5000.00),
            new Employee("赵云", 28, 6666.66),
            new Employee("关羽", 38, 7777.77),
            new Employee("刘备", 48, 10000.88)
    );


    //得到年龄大于18
    public List<Employee> getEmployeeByAge(List<Employee> list) {

        List<Employee> emps = new ArrayList<>();

        for (Employee employee : list) {
            if (employee.getAge() > 18) {
                emps.add(employee);
            }
        }

        return emps;
    }


    //工资大于5000
    public List<Employee> getEmployeeBySalary(List<Employee> list) {

        List<Employee> emps = new ArrayList<>();

        for (Employee employee : list) {
            if (employee.getSalary() > 10000) {
                emps.add(employee);
            }
        }

        return emps;
    }


    @Test
    public void testEmpAge() {
        List<Employee> employeeByAge = getEmployeeByAge(list);
        for (Employee employee : employeeByAge) {
            System.out.println(employee);
        }
    }

    @Test
    public void testEmpSalay() {
        List<Employee> employeeByAge = getEmployeeBySalary(list);
        for (Employee employee : employeeByAge) {
            System.out.println(employee);
        }
    }


    //公用方法
    public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp) {
        List<Employee> list = new ArrayList<>();

        for (Employee employee : emps) {
            if (mp.test(employee)) {
                list.add(employee);
            }
        }

        return list;
    }


    @Test
    public void test01() {
        List<Employee> employeeByAge = filterEmployee(list, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getAge() > 18;
            }
        });
        for (Employee employee : employeeByAge) {
            System.out.println(employee);
        }
    }

    @Test
    public void test02() {
        List<Employee> employeeByAge = filterEmployee(list, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() > 10000;
            }
        });

        for (Employee employee : employeeByAge) {
            System.out.println(employee);
        }
    }


    @Test
    public void test03() {
        List<Employee> employeeByAge = filterEmployee(list, (e) -> e.getAge() > 18);
        employeeByAge.forEach(System.out::println);
    }

    @Test
    public void test04() {
        List<Employee> employeeBySalary = filterEmployee(list, (t) -> t.getSalary() > 5000);
        employeeBySalary.forEach(System.out::println);
    }
}