JDK1.8新特性之（一）--Lambda表达式

       近期由于新冠疫情的原因，不能出去游玩，只能在家呆着。于是闲来无事，开始阅读JDK1.8的源代码。在开始之前也查询了以下JDK1.8的新特性，有针对性的开始了这段旅程。

只看不操作，也是不能心领神会的。而且好脑子不如烂笔头。在这里记载一下自己的学习成果。也算是做一下总结吧。

在正文开始之前先看看JDK1.8都有哪些新特性？

1.Lambda表达式

2.方法引用

3.函数式接口

4.默认方法

5.Stream

6.Optional类

7.Nashorm javascript引擎

8.新的日期时间API

9.Base64

这篇文章先来学习第一个特性--Lambda表达式。

话不多说，下面正式开始学习！

（一）首先介绍以下Lambda表达式是啥？

Lambda表达式也称作闭包，允许把函数作为一个方法的参数，使用Lamba表达式可以使代码变得更加简洁。

（二）Lambda表达式的语法

(参数) -> {代码块}

（三）Lambda表达式的特性

1.可选类型声明：参数的类型可以省，编译器自动识别数据类型。
2.可选的参数圆括号：参数只有一个时候可以省略圆括号。
3.可选的代码块大括号：代码块只有一行的时候可以省略大括号。
4.可选的返回关键字：代码块只有一行且有返回结果，那么return也可以省略。
（四）实例

书写测试类之前先定义以下两个内部接口，供测试时使用。

MathOperation是用于计算数值的接口。

Service是用于提示某些信息的接口。

//定义数学操作接口
interface MathOperation{
    Integer operation(Integer i1,Integer i2);
}

//定义服务接口
interface Service{
    void sayHello(String message);
}

为了便于理解Lambda表达式和更加突出其优点，先用普通的书写方式实现MathOpertation的加法，减法，乘法，除法。

//加法
MathOperation mathOperation1 = new MathOperation() {
    @Override
    public Integer operation(Integer i1, Integer i2) {
        return i1 + i2;
    }
};
System.out.println("1+2=" + mathOperation1.operation(1,2));

//减法
MathOperation mathOperation2 = new MathOperation() {
    @Override
    public Integer operation(Integer i1, Integer i2) {
        return i1 - i2;
    }
};
System.out.println("4-3=" + mathOperation2.operation(4,3));

//乘法
MathOperation mathOperation3 = new MathOperation() {
    @Override
    public Integer operation(Integer i1, Integer i2) {
        return i1 * i2;
    }
};
System.out.println("5*6=" + mathOperation3.operation(5,6));

//除法
MathOperation mathOperation4 = new MathOperation() {
    @Override
    public Integer operation(Integer i1, Integer i2) {
        return i1 / i2;
    }
};
System.out.println("8/2=" + mathOperation4.operation(8,2));

结果：

1+2=3
4-3=1
5*6=30
8/2=4

最先用Lambda表达式的标准实现方式（没有任何省略简写）

//加法
MathOperation mathOperation9 = (Integer i1,Integer i2) -> {return i1 + i2;};
System.out.println("1+2= " + mathOperation9.operation(1,2));

//减法
MathOperation mathOperation10 = (Integer i1,Integer i2) -> {return i1 - i2;};
System.out.println("4-3= " + mathOperation10.operation(4,3));

//乘法
MathOperation mathOperation11 = (Integer i1,Integer i2) -> {return i1 * i2;};
System.out.println("5*6= " + mathOperation11.operation(5,6));

//除法
MathOperation mathOperation12 = (Integer i1,Integer i2) -> {return i1 / i2;};
System.out.println("8/2= " + mathOperation12.operation(8,2));

结果：

1+2= 3
4-3= 1
5*6= 30
8/2= 4

对比上面以前的写法和Lambda表达式的写法，不难看出，从代码量上减少了很多，变得更加简洁。

从深层次的比较就会发现，Lambda表达式替代的就是

new MathOperation() {

    XXXXX//此处省略

};

部分由此得出结论：Lambda表达式的实质就是匿名内部类。

接下来逐一用实例来说明Lambda的特性。

1.可选类型声明：参数的类型可以省，编译器自动识别数据类型。

//加法
MathOperation mathOperation9 = (i1,i2) -> {return i1 + i2;};
System.out.println("1+2= " + mathOperation9.operation(1,2));

//减法
MathOperation mathOperation10 = (i1,i2) -> {return i1 - i2;};
System.out.println("4-3= " + mathOperation10.operation(4,3));

//乘法
MathOperation mathOperation11 = (i1,i2) -> {return i1 * i2;};
System.out.println("5*6= " + mathOperation11.operation(5,6));

//除法
MathOperation mathOperation12 = (i1,i2) -> {return i1 / i2;};
System.out.println("8/2= " + mathOperation12.operation(8,2));

结果：

1+2= 3
4-3= 1
5*6= 30
8/2= 4

2.可选的参数圆括号：参数只有一个时候可以省略圆括号。

//省略版表达式
Service service2 = message -> System.out.println("Hello，" + message);
service2.sayHello("Lambda表达式！");

结果：

Hello，Lambda表达式！

3.可选的代码块大括号：代码块只有一行的时候可以省略大括号。

4.可选的返回关键字：代码块只有一行且有返回结果，那么return也可以省略。

//加法
MathOperation mathOperation13 = (Integer i1,Integer i2) -> i1 + i2;
System.out.println("1+2= " + mathOperation13.operation(1,2));

//减法
MathOperation mathOperation14 = (Integer i1,Integer i2) -> i1 - i2;
System.out.println("4-3= " + mathOperation14.operation(4,3));

//乘法
MathOperation mathOperation15 = (Integer i1,Integer i2) -> i1 * i2;
System.out.println("5*6= " + mathOperation15.operation(5,6));

//除法
MathOperation mathOperation16 = (Integer i1,Integer i2) -> i1 / i2;
System.out.println("8/2= " + mathOperation16.operation(8,2));

结果：

1+2= 3
4-3= 1
5*6= 30
8/2= 4

Lambda表达式除了上面几个特性之外还有几个地方需要注意。

1）Lambda表达式内部可以访问外部的局部变量。

2）Lambda表达式被使用的外部局部变量默认是final类型的，不能修改其值，否则报错。

3）Lambda表达式的内部使用的变量名称不能和外部使用的局部变量名称一样，否则会报错。

1）实例如下

/**
 * Lambda表达式内部可以访问外层的局部变量
 */
//显性final
final String pre_Str1 = "Test1";
Service service3 = message -> System.out.println("显性final:" + pre_Str1 + message);
service3.sayHello(" Jay");

执行结果：

显性final:Test1 Jay

2）实例如下

     当对变量pre_Str2进行修改后，会出现编译错误：local variables referenced from a lambda expression must be final or effectively final。由此说明，引用的变量必须是final类型的。

//隐形final
String pre_Str2 = "Test2";
Service service4 = message -> System.out.println("隐形final:" + pre_Str2 + message);
service4.sayHello(" Jay");

/**
 * Lambda表达中被使用的外部变量默认是final类型的。也就是说不能修改变量的值。
 * 如果试图修改变量的值则会报如下错误
 * Error：local variables referenced from a lambda expression must be final or effectively final
 */
//pre_Str2 ="aaaaa";

3）实例如下

  当在Lambda表达式中使用外部局部变量pre_Str3的时候，编译器报错：ariable pre_Str3 is already defined in method main(java.lang.String[])。由此说明变量的名称不能相同。

/**
 * Lambda表达式的局部变量不可以和外部变量名称相同。
 * 如果Lambda表达式的局部变量和外部变量名称相同则报错。错误信息如下。
 * Error：variable pre_Str3 is already defined in method main(java.lang.String[])
 */
// String pre_Str3 = "Test3";
// Service service5 = pre_Str3 -> System.out.println("变量名测试:" + pre_Str2 + pre_Str3);
// service5.sayHello(" Jay");

以上就是我对Lambda表达式的理解。如果有理解不对或者记述错误的地方欢迎指正，互相学习，提升自己。

下面是我测试的完整类和完整结果。有需要的可以参考。

package com.dream.test.JDK8speciality;

import java.util.*;

/**
 * @author 匠人码农
 * @date 2020/05/04 21:31
 * 概要：
 *     Lambda表达式理解
 *     Lambda格式
 *     （参数） -> {代码块}
 *     注：
 *       1.可选类型声明：参数的类型可以省，编译器自动识别数据类型。
 *       2.可选的参数圆括号：参数只有一个时候可以省略圆括号。
 *       3.可选的代码块大括号：代码块只有一行的时候可以省略大括号。
 *       4.可选的返回关键字：代码块只有一行且有返回结果，那么return也可以省略。
 *       5.Lambda表达式的局部局部变量默认是final类型的。
 *       6.Lambda表达式内部可以引用Lambda表达式外部的局部变量，而且必须是final类型的。
 *       7.Lambda表达式内部的局部变量名称不可以和Lambda表达式外部的局部变量的名称一样。
 */

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

        //没有Lambda表达式之前实现MathOperation的operation方法
        System.out.println("***************************************************");
        System.out.println("* 没有Lambda表达式之前实现MathOperation的operation方法");
        System.out.println("***************************************************");

        //加法
        MathOperation mathOperation1 = new MathOperation() {
            @Override
            public Integer operation(Integer i1, Integer i2) {
                return i1 + i2;
            }
        };
        System.out.println("1+2=" + mathOperation1.operation(1,2));

        //减法
        MathOperation mathOperation2 = new MathOperation() {
            @Override
            public Integer operation(Integer i1, Integer i2) {
                return i1 - i2;
            }
        };
        System.out.println("4-3=" + mathOperation2.operation(4,3));

        //乘法
        MathOperation mathOperation3 = new MathOperation() {
            @Override
            public Integer operation(Integer i1, Integer i2) {
                return i1 * i2;
            }
        };
        System.out.println("5*6=" + mathOperation3.operation(5,6));

        //除法
        MathOperation mathOperation4 = new MathOperation() {
            @Override
            public Integer operation(Integer i1, Integer i2) {
                return i1 / i2;
            }
        };
        System.out.println("8/2=" + mathOperation4.operation(8,2));
        //Lambda表达式
        System.out.println("***************************************************");
        System.out.println("* Lambda表达式写法实现MathOperation的operation方法");
        System.out.println("***************************************************");

        // 标准的Lambda表达式
        System.out.println("*****标准的Lambda表达式书写方式*****");
        //加法
        MathOperation mathOperation5 = (Integer i1,Integer i2) -> {return i1 + i2;};
        System.out.println("1+2= " + mathOperation5.operation(1,2));

        //减法
        MathOperation mathOperation6 = (Integer i1,Integer i2) -> {return i1 - i2;};
        System.out.println("4-3= " + mathOperation6.operation(4,3));

        //乘法
        MathOperation mathOperation7 = (Integer i1,Integer i2) -> {return i1 * i2;};
        System.out.println("5*6= " + mathOperation7.operation(5,6));

        //除法
        MathOperation mathOperation8 = (Integer i1,Integer i2) -> {return i1 / i2;};
        System.out.println("8/2= " + mathOperation8.operation(8,2));

        // 省略参数类型
        System.out.println("*****省略参数类型*****");
        //加法
        MathOperation mathOperation9 = (i1,i2) -> {return i1 + i2;};
        System.out.println("1+2= " + mathOperation9.operation(1,2));

        //减法
        MathOperation mathOperation10 = (i1,i2) -> {return i1 - i2;};
        System.out.println("4-3= " + mathOperation10.operation(4,3));

        //乘法
        MathOperation mathOperation11 = (i1,i2) -> {return i1 * i2;};
        System.out.println("5*6= " + mathOperation11.operation(5,6));

        //除法
        MathOperation mathOperation12 = (i1,i2) -> {return i1 / i2;};
        System.out.println("8/2= " + mathOperation12.operation(8,2));

        // 省略大括号省略return
        System.out.println("*****省略大括号和return*****");
        //加法
        MathOperation mathOperation13 = (Integer i1,Integer i2) -> i1 + i2;
        System.out.println("1+2= " + mathOperation13.operation(1,2));

        //减法
        MathOperation mathOperation14 = (Integer i1,Integer i2) -> i1 - i2;
        System.out.println("4-3= " + mathOperation14.operation(4,3));

        //乘法
        MathOperation mathOperation15 = (Integer i1,Integer i2) -> i1 * i2;
        System.out.println("5*6= " + mathOperation15.operation(5,6));

        //除法
        MathOperation mathOperation16 = (Integer i1,Integer i2) -> i1 / i2;
        System.out.println("8/2= " + mathOperation16.operation(8,2));

        //没有Lambda表达式之前的写法
        Service service0 = new Service() {
            @Override
            public void sayHello(String message) {
                System.out.println("hello: " + message);
            }
        };
        service0.sayHello("没有Lambda表达式之前的写法！！！");

        //完整版表达式
        Service service1 = (message) -> {
            System.out.println("this is my " + message);
        };
        service1.sayHello("Lambda表达式测试！");

        //省略版表达式
        Service service2 = message -> System.out.println("Hello，" + message);
        service2.sayHello("Lambda表达式！");

        /**
         * Lambda表达式内部可以访问外层的局部变量
         */
        //显性final
        final String pre_Str1 = "Test1";
        Service service3 = message -> System.out.println("显性final:" + pre_Str1 + message);
        service3.sayHello(" Jay");

        //隐形final
        String pre_Str2 = "Test2";
        Service service4 = message -> System.out.println("隐形final:" + pre_Str2 + message);
        service4.sayHello(" Jay");

        /**
         * Lambda表达中被使用的外部变量默认是final类型的。也就是说不能修改变量的值。
         * 如果试图修改变量的值则会报如下错误
         * Error：local variables referenced from a lambda expression must be final or effectively final
         */
        //pre_Str2 ="aaaaa";

        /**
         * Lambda表达式的局部变量不可以和外部变量名称相同。
         * 如果Lambda表达式的局部变量和外部变量名称相同则报错。错误信息如下。
         * Error：variable pre_Str3 is already defined in method main(java.lang.String[])
         */
        //String pre_Str3 = "Test3";
        //Service service5 = pre_Str3 -> System.out.println("变量名测试:" + pre_Str2 + pre_Str3);
        //service5.sayHello(" Jay");

    }

    //定义数学操作接口
    interface MathOperation{
        Integer operation(Integer i1,Integer i2);
    }

    //定义服务接口
    interface Service{
        void sayHello(String message);
    }

}

结果

 下一篇文章

JDK1.8新特性之（二）--方法引用