Java8新特性_Lambda表达式初体验

Java8新特性_Lambda表达式初体验

昨夜西风凋碧树，独上高楼，望尽天涯路

一、Lambda表达式

Lambda 是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

二、由匿名内部类到Lambda表达式

1.原来的匿名内部类

    //匿名内部类
    @Test
    public void test1() {
        Comparator<Integer> comparator = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
    }

2.Lambda表达式

    //Lambda表达式
    @Test
    public void test2() {
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x,y);
        TreeSet<Integer> treeSet = new TreeSet<>(comparator);
    }

三、实例

需求：
1.获取当前公司中员工年龄大于35的员工信息
2.获取当前公司中员工工资大于5000的员工信息

员工集合

//数组转集合
    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,1999),
            new Employee("李四",28,2999),
            new Employee("王五",38,3999),
            new Employee("赵六",48,4999),
            new Employee("田七",58,5999)
    );

    @Test
    public void test3() {
        List<Employee> list = filterEmployee(employees);

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

    //需求：获取当前公司中员工年龄大于35的员工信息
    public List<Employee> filterEmployee(List<Employee> list) {
        List<Employee> employees = new ArrayList<>();

        for (Employee employee : list) {
            if (employee.getAge() > 35) {
                employees.add(employee);
            }
        }
        return employees;
    }

    //需求：获取当前公司中员工工资大大于5000的员工信息
    public List<Employee> filterEmployee2(List<Employee> list) {
        List<Employee> employees = new ArrayList<>();

        for (Employee employee : list) {
            if (employee.getSalary() > 5000) {
                employees.add(employee);
            }
        }
        return employees;
    }

缺点：代码冗余过多

优化方式一：策略设计模式

/**
 * @Author: slx
 * @Date: 2019/4/9 19:40
 */
public interface MyPredicate<T> {
    boolean test(T t);
}

/**
 * @Author: slx
 * @Date: 2019/4/9 19:41
 */
public class FilterEmployeeByAge implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee employee) {
        return employee.getAge() > 35;
    }
}

/**
 * @Author: slx
 * @Date: 2019/4/9 19:53
 */
public class FilterEmployeeBySalary implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee employee) {
        return employee.getSalary() > 5000;
    }
}

    //优化方式一：策略设计模式
    @Test
    public void test4() {
        List<Employee> list = filterEmployee(employees, new FilterEmployeeByAge());

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

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

        List<Employee> list2 = filterEmployee(employees, new FilterEmployeeBySalary());

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

    public List<Employee> filterEmployee(List<Employee> list, MyPredicate<Employee> employeeMyPredicate) {
        List<Employee> employees = new ArrayList<>();

        for (Employee employee : list) {
            if (employeeMyPredicate.test(employee)) {
                employees.add(employee);
            }
        }
        return employees;
    }

优化方式二：匿名内部类

@Test
    public void test5() {
        List<Employee> list = filterEmployee(employees, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() < 5000;
            }
        });
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

优化方式三：Lambda表达式

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

优化方式四：Stream API

    @Test
    public void test7() {
        employees.stream()
                .filter((e) -> e.getSalary() > 5000)
                .limit(2)
                .forEach(System.out :: println);

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

        employees.stream()
                .map(Employee::getName)
                .forEach(System.out :: println);
    }

可见java8的Lambda表达式方式更简洁、更灵活