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{ 3  Integer operation(Integer i1,Integer i2); 4 } 5 
//定义服务接口
interface Service{ 8     void sayHello(String message); 9 }

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

//加法
MathOperation mathOperation1 = new MathOperation() {  3  @Override  4     public Integer operation(Integer i1, Integer i2) {  5         return i1 + i2;  6  }  7 };  8 System.out.println("1+2=" + mathOperation1.operation(1,2));  9 
//减法
MathOperation mathOperation2 = new MathOperation() { 12  @Override 13     public Integer operation(Integer i1, Integer i2) { 14         return i1 - i2; 15  } 16 }; 17 System.out.println("4-3=" + mathOperation2.operation(4,3)); 18 
//乘法
MathOperation mathOperation3 = new MathOperation() { 21  @Override 22     public Integer operation(Integer i1, Integer i2) { 23         return i1 * i2; 24  } 25 }; 26 System.out.println("5*6=" + mathOperation3.operation(5,6)); 27 
//除法
MathOperation mathOperation4 = new MathOperation() { 30  @Override 31     public Integer operation(Integer i1, Integer i2) { 32         return i1 / i2; 33  } 34 }; 35 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;};  3 System.out.println("1+2= " + mathOperation9.operation(1,2));  4 
//减法
MathOperation mathOperation10 = (Integer i1,Integer i2) -> {return i1 - i2;};  7 System.out.println("4-3= " + mathOperation10.operation(4,3));  8 
//乘法
MathOperation mathOperation11 = (Integer i1,Integer i2) -> {return i1 * i2;}; 11 System.out.println("5*6= " + mathOperation11.operation(5,6)); 12 
//除法
MathOperation mathOperation12 = (Integer i1,Integer i2) -> {return i1 / i2;}; 15 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;};  3 System.out.println("1+2= " + mathOperation9.operation(1,2));  4 
//减法
MathOperation mathOperation10 = (i1,i2) -> {return i1 - i2;};  7 System.out.println("4-3= " + mathOperation10.operation(4,3));  8 
//乘法
MathOperation mathOperation11 = (i1,i2) -> {return i1 * i2;}; 11 System.out.println("5*6= " + mathOperation11.operation(5,6)); 12 
//除法
MathOperation mathOperation12 = (i1,i2) -> {return i1 / i2;}; 15 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); 3 service2.sayHello("Lambda表达式！");

结果：

Hello，Lambda表达式！

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

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

//加法
MathOperation mathOperation13 = (Integer i1,Integer i2) -> i1 + i2;  3 System.out.println("1+2= " + mathOperation13.operation(1,2));  4 
//减法
MathOperation mathOperation14 = (Integer i1,Integer i2) -> i1 - i2;  7 System.out.println("4-3= " + mathOperation14.operation(4,3));  8 
//乘法
MathOperation mathOperation15 = (Integer i1,Integer i2) -> i1 * i2; 11 System.out.println("5*6= " + mathOperation15.operation(5,6)); 12 
//除法
MathOperation mathOperation16 = (Integer i1,Integer i2) -> i1 / i2; 15 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表达式内部可以访问外层的局部变量  3  */
//显性final
final String pre_Str1 = "Test1";  6 Service service3 = message -> System.out.println("显性final:" + pre_Str1 + message);  7 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";  3 Service service4 = message -> System.out.println("隐形final:" + pre_Str2 + message);  4 service4.sayHello(" Jay");  5 
/**
 * Lambda表达中被使用的外部变量默认是final类型的。也就是说不能修改变量的值。  8  * 如果试图修改变量的值则会报如下错误  9  * Error：local variables referenced from a lambda expression must be final or effectively final 10  */
//pre_Str2 ="aaaaa";

3）实例如下

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

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

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

 

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

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

public class LambdaTest {  23     public static void main(String[] args) {  24 
        //没有Lambda表达式之前实现MathOperation的operation方法
        System.out.println("***************************************************");  27         System.out.println("* 没有Lambda表达式之前实现MathOperation的operation方法");  28         System.out.println("***************************************************");  29 
        //加法
        MathOperation mathOperation1 = new MathOperation() {  32  @Override  33             public Integer operation(Integer i1, Integer i2) {  34                 return i1 + i2;  35  }  36  };  37         System.out.println("1+2=" + mathOperation1.operation(1,2));  38 
        //减法
        MathOperation mathOperation2 = new MathOperation() {  41  @Override  42             public Integer operation(Integer i1, Integer i2) {  43                 return i1 - i2;  44  }  45  };  46         System.out.println("4-3=" + mathOperation2.operation(4,3));  47 
        //乘法
        MathOperation mathOperation3 = new MathOperation() {  50  @Override  51             public Integer operation(Integer i1, Integer i2) {  52                 return i1 * i2;  53  }  54  };  55         System.out.println("5*6=" + mathOperation3.operation(5,6));  56 
        //除法
        MathOperation mathOperation4 = new MathOperation() {  59  @Override  60             public Integer operation(Integer i1, Integer i2) {  61                 return i1 / i2;  62  }  63  };  64         System.out.println("8/2=" + mathOperation4.operation(8,2));  65         //Lambda表达式
        System.out.println("***************************************************");  67         System.out.println("* Lambda表达式写法实现MathOperation的operation方法");  68         System.out.println("***************************************************");  69 
        // 标准的Lambda表达式
        System.out.println("*****标准的Lambda表达式书写方式*****");  72         //加法
        MathOperation mathOperation5 = (Integer i1,Integer i2) -> {return i1 + i2;};  74         System.out.println("1+2= " + mathOperation5.operation(1,2));  75 
        //减法
        MathOperation mathOperation6 = (Integer i1,Integer i2) -> {return i1 - i2;};  78         System.out.println("4-3= " + mathOperation6.operation(4,3));  79 
        //乘法
        MathOperation mathOperation7 = (Integer i1,Integer i2) -> {return i1 * i2;};  82         System.out.println("5*6= " + mathOperation7.operation(5,6));  83 
        //除法
        MathOperation mathOperation8 = (Integer i1,Integer i2) -> {return i1 / i2;};  86         System.out.println("8/2= " + mathOperation8.operation(8,2));  87 
        // 省略参数类型
        System.out.println("*****省略参数类型*****");  90         //加法
        MathOperation mathOperation9 = (i1,i2) -> {return i1 + i2;};  92         System.out.println("1+2= " + mathOperation9.operation(1,2));  93 
        //减法
        MathOperation mathOperation10 = (i1,i2) -> {return i1 - i2;};  96         System.out.println("4-3= " + mathOperation10.operation(4,3));  97 
        //乘法
        MathOperation mathOperation11 = (i1,i2) -> {return i1 * i2;}; 100         System.out.println("5*6= " + mathOperation11.operation(5,6)); 101 
        //除法
        MathOperation mathOperation12 = (i1,i2) -> {return i1 / i2;}; 104         System.out.println("8/2= " + mathOperation12.operation(8,2)); 105 
        // 省略大括号省略return
        System.out.println("*****省略大括号和return*****"); 108         //加法
        MathOperation mathOperation13 = (Integer i1,Integer i2) -> i1 + i2; 110         System.out.println("1+2= " + mathOperation13.operation(1,2)); 111 
        //减法
        MathOperation mathOperation14 = (Integer i1,Integer i2) -> i1 - i2; 114         System.out.println("4-3= " + mathOperation14.operation(4,3)); 115 
        //乘法
        MathOperation mathOperation15 = (Integer i1,Integer i2) -> i1 * i2; 118         System.out.println("5*6= " + mathOperation15.operation(5,6)); 119 
        //除法
        MathOperation mathOperation16 = (Integer i1,Integer i2) -> i1 / i2; 122         System.out.println("8/2= " + mathOperation16.operation(8,2)); 123 
        //没有Lambda表达式之前的写法
        Service service0 = new Service() { 126  @Override 127             public void sayHello(String message) { 128                 System.out.println("hello: " + message); 129  } 130  }; 131         service0.sayHello("没有Lambda表达式之前的写法！！！"); 132 
        //完整版表达式
        Service service1 = (message) -> { 135             System.out.println("this is my " + message); 136  }; 137         service1.sayHello("Lambda表达式测试！"); 138 
        //省略版表达式
        Service service2 = message -> System.out.println("Hello，" + message); 141         service2.sayHello("Lambda表达式！"); 142 
        /**
 * Lambda表达式内部可以访问外层的局部变量 145          */
        //显性final
        final String pre_Str1 = "Test1"; 148         Service service3 = message -> System.out.println("显性final:" + pre_Str1 + message); 149         service3.sayHello(" Jay"); 150 
        //隐形final
        String pre_Str2 = "Test2"; 153         Service service4 = message -> System.out.println("隐形final:" + pre_Str2 + message); 154         service4.sayHello(" Jay"); 155 
        /**
 * Lambda表达中被使用的外部变量默认是final类型的。也就是说不能修改变量的值。 158  * 如果试图修改变量的值则会报如下错误 159  * Error：local variables referenced from a lambda expression must be final or effectively final 160          */
        //pre_Str2 ="aaaaa";

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

 } 173 
    //定义数学操作接口
    interface MathOperation{ 176  Integer operation(Integer i1,Integer i2); 177  } 178 
    //定义服务接口
    interface Service{ 181         void sayHello(String message); 182  } 183 
}

结果

 

 下一篇文章

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