Lambda表达式学习（一）为什么使用Lambda表达式？

java8已经出来很久了，一直没去学习Java的新特性，感觉out了，偶然看见了，感觉用法还是挺简单的，也挺有趣，于是学习了一下，现在写一些学习的笔记。
首先说一下为什么要使用Lambda表达式？
在回答这个问题之前我先举个栗子：

在这里有一个员工的集合，员工类我就省略不写了，也就是id,age,name,salary这几个属性，无参，有参的构造函数，然后实现他们setter,getter方法，

List<Employee> emps = Arrays.asList(
            new Employee(101, "张三", 18, 9999),
            new Employee(102, "李四", 59, 6666),
            new Employee(103, "王五", 18, 3333),
            new Employee(104, "赵六", 8, 7777),
            new Employee(105, "田七", 28, 5555)
    );

写一个测试方法，现在有这么一个需求，就是获取员工集合中年龄大于20岁的员工的集合，在之前我们大部分我想应该都是这样写的吧：

    public List<Employee> filterEmployeeAge(List<Employee> emps){
        List<Employee> list = new ArrayList<>();
        for (Employee emp : emps) {
            if(emp.getAge() > 20){
                list.add(emp);
            }
        }
        return list;
    }

ok,这样是能很完美的解决问题，很符合现实的逻辑，但是现在我们对这段代码进行优化，在优化的过程中会慢慢演变到主题Lambda的使用：

优化方式一：
我先创建一个泛型接口，接口里面只有一个方法。

public interface MyPredicate<T> {
    boolean test(T t);
}

再写一个接口的实现类：

public class FilterEmployeeForAge implements MyPredicate<Employee>{
    @Override
    public boolean test(Employee t) {
        return t.getAge() >20;
    }
}

接下来就是优化的关键代码：

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 filterEmployeeByAge(){
    List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
    for (Employee employee : list) {
        System.out.println(employee);
    }       
}

上面的测试代码的关键方法是filterEmployee,通过传入的员工列表和你过滤的方式，而FilterEmployeeForAge是MyPredicate的实现类，在filterEmployee中对每个员工进行判断，然后决定是否要加入到集合中。如果你下次判断的不是age而是salary，就可以另外写一个MyPredicate的实现类，实现你自己想要的过滤的方式就可以了。
其实上面的优化方案就是设计模式中的策略设计模式，在这边讲的是Lambda表达式，所以这里就提一下，有兴趣的同学可以去看看。

上面是优化方式一的实现的一个思路，现在我在说一下第二种优化方案：
优化方式二：匿名内部类

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

通过匿名内部类就不需要在去写接口的实现类了，看到这里，小伙伴们是不是着急了，想看看我们表达式怎么用呢？好的，接下来我就说一下Lambda表达式怎么使用。
优化方式三：Lambda表达式

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

这样代码是不是很简洁。ok，如果你还看不出来它的简洁我在给你举个栗子：

之前我们在比较两个数的时候用的是匿名内部类

Comparator<String> com = new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        };

我们需要四五行的代码，而现在用Lambda表达式，看看代码怎么写：

Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());

对比结果显而易见，就一行代码搞定，看到这里你是不是也感兴趣了？现在我就开始仔细的讲一讲Lambda表达式是怎么使用的。
Lambda表达式学习（二）Lambda基础语法