Java8 Lambda 表达式

可参考博文:
http://blog.youkuaiyun.com/codejas/article/details/78810719
在学习Lambda 之前可以先了解一下java8 中关于接口的变化，以及函数式接口的定义及作用。

(一)Lambda 表达式介绍与语法格式

1.1Lambda 介绍

Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。这样做可以写出更简洁、更灵活的代码。

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “->”， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分。

左侧：指定了 Lambda 表达式需要的所有参数。
右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

1.2Lambda 格式

语法格式一：无参，无返回值

Runnable runnable = () -> System.out.println("Hello Lambda!");

语法格式二：Lambda 需要一个参数

 Consumer<String> fun1 = (parameter) -> System.out.println(parameter);

语法格式三：Lambda 只需要一个参数时，参数的小括号可以省略

 Consumer<String> fun2 = parameter -> System.out.println(parameter);

语法格式四：Lambda 需要两个参数，并且有返回值

BinaryOperator<Long> bo3 = (Long x, Long y) ->{
            System.out.println("实现函数接口方法！");
            return x + y;
        };

语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略

BinaryOperator<Long> bo2 = (x, y) -> x + y;

1.3类型推断

BinaryOperator<Long> bo1 = (x, y) ->{
            System.out.println("实现函数接口方法！");
            return x + y;
        };

参考格式四，你会发现在传递参数的可以不用指定参数的类型，因为编译器推可以自动断出参数的数据类型。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数类型。

(二)Lambda 表达式简单应用

2.1Runnable 无返回值应用

Runnable 接口中只有一个抽象方法run() ，并且使用了@FunctionalInterface 注解，表明它是一个函数式接口，所以它允许使用Lambda 表达式，下面是Java8 中Runnable 接口的源码。

@FunctionalInterface
public interface Runnable {

    public abstract void run();
}

以前我们编写多线程程序的时候一般都是定义一个类去实现Runnable 接口或者写一个Runnable 实现的匿名内部类来定义任务，然后启动它。现在我们了解了Lambda 表达式可以用更简单的方式去实现它。

public class LambdaTest {
    public static void main(String[] args) {

        /*  Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello");      
            }
        };
        new Thread(runnable).start();*/

        // Lambda 方式定义实现
        Runnable runnable1 = () -> System.out.print("Hello");
        new Thread(runnable1).start();
    }
}

输出
Hello

2.2Callable 有返回值应用

Callable 接口与Runnable 接口类似，它也是只有一个抽象方法，只不过这个抽象方法是call()，具体源码如下。所以说它也是一个函数式接口。

@FunctionalInterface
public interface Callable<V> {

    V call() throws Exception;
}

Callable 接口允许我们从运行后的线程中获得返回值，下面我们用Lambda 表达式去实现一个简单的计算：开启一个线程去计算1-100 数字叠加的和。

public class LambdaTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Callable<Integer> callable = () -> {
            int num = 0;
            for(int i = 0 ;i <= 100 ;i++)
                num += i;
            return num;
        } ;

        FutureTask<Integer> result = new FutureTask<>(callable);
        new Thread(result).start();
        System.out.print(result.get());
    }
}

输出
5050

2.3具体应用

下面是一个示例：定义一个员工类：包含字段username、age、gender和salary。这里我们以三种不同的方式区实现下面的需求。

需求：
①查找出薪水大于等于5000 的员工信息；
②查找出年龄大于等于20 岁的员工信息。

下面是员工类

public class Employee {
    private String username;
    private int age;
    private char gender; 
    private int salary;

    /** 省略get 与set 方法 */

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

方式一：通过最简单的方式遍历集合，代码复用性很差

//所有员工信息的集合，下面的两种实现方式也都使用employeesList 集合
 List<Employee> employeesList = Arrays.asList(
            new Employee("小明",20,'男',5000),
            new Employee("小王",22,'男',4000),
            new Employee("小花",18,'女',5500),
            new Employee("小李",25,'男',6000));

 //通过遍历的形式将薪水条件符合的员工信息添加到集合中，返回条件符合的集合            
 public List<Employee> getEmployeesBySalary(List<Employee> employees) {
        List<Employee> list = new ArrayList<>();
        for(Employee employee : employees){
            if(employee.getSalary() >= 5000)
                list.add(employee);
        }
        return list;
    }
    @Test
    public void test1(){
        List<Employee> list = getEmployeesBySalary(employeesList);
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

    //通过遍历的形式将年龄条件符合的员工信息添加到集合中，返回条件符合的集合
    public List<Employee> getEmployeesByAge(List<Employee> employees) {
        List<Employee> list = new ArrayList<>();
        for(Employee employee : employees){
            if(employee.getAge() >= 20)
                list.add(employee);
        }
        return list;
    }
    @Test
    public void test2(){
        List<Employee> list = getEmployeesByAge(employeesList);
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

方式二：简单策略模式

策略接口

    //定义策略接口,因为该接口只有一个抽象方法所以也是一个函数式接口
    public interface MyStrategy<Employee>{
        boolean test(Employee employee);
    }

测试

    //返回符合条件的员工集合
     public List<Employee> filterEmployees(List<Employee> employees , MyStrategy<Employee> strategy) {
        List<Employee> list = new ArrayList<>();
        for(Employee employee : employees) {
            if(strategy.test(employee))    //根据策略添加符合对应条件的员工
                list.add(employee);
        }
        return list;
    }
    //为了避免复杂不定义策略类直接传入一个MyStrategy 形式的匿名内部类的实现，输出薪水条件符合的员工
    @Test
    public void test5(){
        List<Employee> list = filterEmployees(employeesList, new MyStrategy<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getSalary() >= 5000;
            }
        });
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

     //输出年龄条件符合的员工
    @Test
    public void test6(){
        List<Employee> list = filterEmployees(employeesList, new MyStrategy<Employee>() {
            @Override
            public boolean test(Employee employee) {
                return employee.getAge() >= 20;
            }
        });
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

方式三：策略模式 + Lambda 表达式

    /** 这里仍然用到了策略模式，我们不用传入MyStrategy 的实现类，代码更加简洁了 */
    @Test
    public void test7(){
        List<Employee> list = filterEmployees(employeesList, (e) -> e.getSalary() >= 5000);
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

    @Test
    public void test8(){
        List<Employee> list = filterEmployees(employeesList, (e) -> e.getAge() >= 20);
        for(Employee employee : list){
            System.out.println(employee);
        }
    }

(三)总结

这篇博文主要介绍了Lambda 的相关概念、使用方式，并通过具体的简单例子体会到了Lambda 的简洁。希望这篇博文能够为初学Lambda 的读者提供帮助。