「lambda表达式」Java中Lambda表达式的使用

lambda表达式

作者：叁念

一、lambda表达式是什么？

Lambda（ λ）希腊字母表的第11个字母，不说官方术语。在java中我们可以将其理解为将面向对象中的传递数据变成传递行为（函数），也就是说允许你通过表达式来代替功能接口。
需要注意的是，它有参数列表、函数主体、返回值类型等，但是它没有名称，所以它传递的函数准确的来说应该是会传递匿名函数。
Lambda表达式有好处也有坏处，它可以帮助你使用更少的代码来实现相同的功能，代码简洁清爽。但是网上也有好多人不推荐使用这个方式编写代码，原因是这些代码相对来说比较难懂、难以调试以及维护。所以仁者见仁智者见智，什么时候用就看业务需求了。

二、基本语法

2.1 语法

``` (parameters) -> expression ``` ``` (parameters) ->{ statements; } ``` 简单来说，Lambda表达式由参数、箭头、主体组成有些特性可以看以下内容与代码引用：（[内容来自](http://www.runoob.com/java/java8-lambda-expressions.html)）

书写参数类型时，不需要刻意声明，编译器可以自动识别

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

2.2 常用案例

2.2.1 常用用法

``` 不接受参数，返回值 () -> 5 创建对象（不接受参数，创建并返回一个对象） () -> new APPle(10) 布尔表达式（接收一个list参数，返回是否为空） (List list) -> list.isempty() 使用对象（接收一个对象，调用其方法） (Person p) -> {System.out.println(p.getName());} 计算两个值（接收两个参数，计算并返回值） (int a, int b) -> a * b 比较两个对象（接收两个对象，比较并返回值） (Person p1, Person p2) ->a1.getAge().compareTo(a2.getAge()) ```

2.2.2 Lambda与函数式接口一览

``` public class LambdaDemo { static String salutation = "Hello! ";

public static void main(String args[]){
    GreetingService greetService1 = message ->
            System.out.println(salutation + message);
    greetService1.sayMessage("Runoob");
}

/*** 函数式接口*/
interface GreetingService {
    void sayMessage(String message);
}

}

对于函数式接口不深究，我们只要知道它有以下特点：

 - 函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
 - 函数式接口可以被隐式转换为lambda表达式。
 -  jdk源码中会存在注解 <font color=red>@FunctionalInterface</font> ，如下package java.lang;中的Runnable 接口：

@FunctionalInterface

public interface Runnable {

public abstract void run();

}


<h6>2.2.3 用法实例（学习）</h6>

public class Java8Tester {

/*** 函数式接口 MathOperation /

interface MathOperation {

int operation(int a, int b);

}

/** 函数式接口 GreetingService /

interface GreetingService {

void sayMessage(String message);

}

/** 函数式接口 operate*/

private int operate(int a, int b, MathOperation mathOperation){

return mathOperation.operation(a, b);

}

public static void main(String args[]){

Java8Tester tester = new Java8Tester();

// 类型声明

MathOperation addition = (int a, int b) -> a + b;

// 不用类型声明

MathOperation subtraction = (a, b) -> a - b;

// 大括号中的返回语句

MathOperation multiplication = (int a, int b) -> { return a * b; };

// 没有大括号及返回语句

MathOperation pision = (int a, int b) -> a / b;

  System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
  System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
  System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
  System.out.println("10 / 5 = " + tester.operate(10, 5, pision));
    
  // 不用括号
  GreetingService greetService1 = message ->
  System.out.println("Hello " + message);
  // 用括号
  GreetingService greetService2 = (message) ->
  System.out.println("Hello " + message);
    
  greetService1.sayMessage("Runoob");
  greetService2.sayMessage("Google");

}


<h4>三、使用说明</h4>
<h5>3.1 案例一 : 操作List，遍历取值</h5>

    List<String> wordList = Arrays.asList("a", "b", "c", "d", "e", "f");
    /*** 打印信息（旧方法）*/
    for(String s:wordList){
        System.out.print(s);
    }
    /*** 打印信息(lambda 表达式)*/
    wordList.foreach(str -> System.out.print(str));
    /*** Java 8 中使用双冒号操作符(拓展)*/
    wordList.forEach(System.out::print);

<h5>3.2 案例二 : 操作List，排序</h5>

    integer [] arr = {9,3,2,8,5,6,7,4,1};
    /**
     * 使用匿名内部类排序（旧方法）
     */
    arrays.sort(arr, new Comparator<Integer>() {
        @Override
        public int compare(Integer x, Integer y) {
            return (x < y) ? -1 : ((x.equals(y)) ? 0 : 1);
        }
    });
    /**
     * 排序（lambda）
     */
    Arrays.sort(arr,(Integer x,Integer y) ->((x < y) ? -1 : ((x.equals(y)) ? 0 : 1)));


<h5>3.2 案例三 : 操作map</h5>

    /**
     * 关于stream下一篇文章会进行讲解
     */
    List<Integer> list = Arrays.asList(2, 4, 6, 8, 10);
    list.stream().map(x -> x * 2).forEach(System.out::print);
    //或者如下
    list.stream().map(x -> x * 2).forEach(x ->System.out.print(x));


<h5>3.2 案例四 : 实现 Runnable接口（替代匿名内部类）</h5>

    /*** 创建线程（旧方法）*/
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.print("new Runnable with old");
        }
    }).start();
    /*** 创建线程（lambda ）*/
    new Thread(() -> System.out.print("new Runnable with lambda")).start();

Java中Lambda表达式的使用