java8lambda表达式

截至目前为止，jdk12都出来小半年了，楼主之前不太喜欢lambda表达式，觉得可读性差，不愿意去研究，后来发现组里好多同学都在使用，

而且让冗余的代码逻辑变得简单，所以就也研究了一下，同时记录下来，方便以后忘了可以复习

======================================================================

一.基础语法

lambda 表达式的语法格式如下：

(parameters) -> expression

(parameters) ->{ statements; }

以下是lambda表达式的重要特征：

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

Lambda 主体根据以下选项之一返回结果：

如果 lambda 主体是单一表达式，则返回表达式的值（如果有的话）。
如果功能接口方法的结果是 void，可以提供一个 return 语句，但这不是必需的。
如果功能接口方法具有返回类型，且 lambda 主体不是单一表达式，则 lambda 主体必须使用 return 语句返回匹配的值。

语句块必须包含在大括号内，除非语句块是一个方法调用语句，且功能接口方法的返回结果是void。

Lambda 表达式实际上是一种匿名方法实现，指定形式参数，并使用 return 语句返回值。匿名方法必须按照以下规则所规定的与其实现的功能接口方法兼容。

Lambda 表达式返回的结果必须与功能接口方法的结果兼容。返回值的类型可以是功能接口方法声明中返回类型的子类型。
Lambda 表达式签名必须与功能接口方法的签名相同。
Lambda 表达式只能抛出那些在功能接口方法的 throws 子句中声明了异常类型或异常超类型的异常。

Lambda 表达式的简单例子:
// 1. 不需要参数,返回值为 5
() -> 5

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y

// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
(x, y) -> {return x – y} ;

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

package com.lamada;
 
/**
 * @author luohaojie
 * @snice 2019-06-04 14:37
 * 基础语法
 **/
public class LambdaTest {
    /**
     * 计算接口
     */
    interface MathOperation {
        int operation(int a, int b);
    }
 
    /**
     * 发送信息接口
     */
    interface GreetingService {
        void sayMessage(String message);
    }
 
    public static void main(String[] args) {
        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;


    // 不用类型声明
    MathOperation subtraction = (a, b) -> a - b;

    // 大括号中的返回语句
    MathOperation multiplication = (int a, int b) -> {
        return a * b;
    };

    // 没有大括号及返回语句
    MathOperation division = (int a, int b) -> a / b;


    LambdaTest lambdaTest = new LambdaTest();

    System.out.println("10 + 5 = " + lambdaTest.operate(10, 5, addition));
    System.out.println("10 - 5 = " + lambdaTest.operate(10, 5, subtraction));
    System.out.println("10 x 5 = " + lambdaTest.operate(10, 5, multiplication));
    System.out.println("10 / 5 = " + lambdaTest.operate(10, 5, division));

    // 不用括号
    GreetingService greetService1 = message ->
            System.out.println("Hello " + message);

    // 用括号
    GreetingService greetService2 = (message) ->
            System.out.println("Hello " + message);

    greetService1.sayMessage("Baidu");
    greetService2.sayMessage("Google");
}

private int operate(int a, int b, MathOperation mathOperation) {
    return mathOperation.operation(a, b);
}

}

//打印
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Baidu
Hello Google

二.lambda表达式具体用法
1.对集合进行遍历

package com.lamada;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
/**
 * @author luohaojie
 * @snice 2019-06-04 14:38
 * 对集合进行遍历
 **/
public class LambdaTest2 {
 
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        Person person1 = new Person("Bod", 13);
        Person person2 = new Person("Lucy", 14);
        Person person3 = new Person("Curry", 15);
        personList.add(person1);
        personList.add(person2);
        personList.add(person3);
 
        //传统的遍历
        for (Person person : personList) {
            System.out.println(person);
        }
        System.out.println("===================================");
        //使用 lambda 表达式以及函数操作
        //遍历
        personList.forEach(person -> {
            System.out.println(person);
        });
        //过滤
        personList.stream().filter(person -> person.getAge() == 13).collect(Collectors.toList());
        System.out.println("===================================");
      
 
        Map<Integer, Person> personMap = new HashMap<>();
        personMap.put(1, person1);
        personMap.put(2, person2);
        personMap.put(3, person3);
 
        //传统的遍历
        for (Map.Entry<Integer, Person> entry : personMap.entrySet()) {
            System.out.println("count : " + entry.getKey() + " person : " + entry.getValue());
        }
        System.out.println("===================================");
        //使用 lambda 表达式遍历
        personMap.forEach((key, value) -> {
            System.out.println("count : " + key + " person : " + value);
        });
         
 
    }
}
//打印
Person{name='Bod', age=13}
Person{name='Lucy', age=14}
Person{name='Curry', age=15}
===================================
Person{name='Bod', age=13}
Person{name='Lucy', age=14}
Person{name='Curry', age=15}
===================================
count : 1 person : Person{name='Bod', age=13}
count : 2 person : Person{name='Lucy', age=14}
count : 3 person : Person{name='Curry', age=15}
===================================
count : 1 person : Person{name='Bod', age=13}
count : 2 person : Person{name='Lucy', age=14}
count : 3 person : Person{name='Curry', age=15}

2.匿名内部类

package com.lamada;
 
/**
 * @author luohaojie
 * @snice 2019-06-04 15:29
 **/
public class LambdaTest3 {
    public static void main(String[] args) {
        //传统的内部类
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程打印");
            }
        });
        thread.start();
 
        //lambda表达式
        new Thread(() -> System.out.println("线程打印")).start();
 
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello world !");
            }
        };
 
        runnable.run();
 
 
        //lambda表达式
        Runnable runnable2 = () -> System.out.println("Hello world !");
        runnable2.run();
    }
 
 
}
//打印
  
线程打印
线程打印
Hello world !
Hello world !