jdk1.8学习、jdk1.9学习、jdk10.0学习和总结

由于中文参考资料很少，参考链接：

https://www.oschina.net/translate/109-new-features-in-jdk-10

1、jdk10.0特性，局部变量类型推断，var保留字，只要编译器可以推断此种类型，你不再需要专门声明一个局部变量的类型。对于JDK10

来讲最为显著的就是引入了局部类型变量推断这个特性

 1 package com.bie.lesson1;
 2 
 3 public class Student {
 4     
 5     //此处报错,因为var必须作为局部变量使用
 6     //var a = 10;
 7     
 8     public static void show() {
 9         //只要编译器可以推断此种类型,你不再需要专门声明一个局部变量的类型。
10         var a = 10;
11         System.out.println(a + "局部变量可以使用var");
12     }
13     
14     public static void main(String[] args) {
15         Student.show();
16     }
17     
18 }

更多使用案例如下所示：

 1 package com.bie.lesson1;
 2 
 3 import java.util.ArrayList;
 4 
 5 public class Student {
 6 
 7     // 1、此处报错,因为var必须作为局部变量使用
 8     // var a = 10;
 9 
10     public static void show() {
11         // 1、只要编译器可以推断此种类型,你不再需要专门声明一个局部变量的类型。
12         var a = 10;
13         System.out.println(a + "局部变量可以使用var");
14     }
15 
16     /**
17      * 1、增量for循环的使用局部变量类型的定义
18      */
19     public static void showList() {
20         var list = new ArrayList<Integer>();
21         list.add(1);
22         list.add(11);
23         list.add(111);
24         list.add(1111);
25         list.add(11111);
26         for (var a : list) {
27             System.out.println(a);
28         }
29     }
30 
31     /**
32      * 1、普通for循环的使用局部变量类型的定义
33      */
34     public static void showArray() {
35         int[] a = { 1, 2, 3, 4, 5 };
36         for(var i=0;i<a.length;i++) {
37             System.out.println(a[i]);
38         }
39     }
40 
41     public static void main(String[] args) {
42         // 1、局部变量类型推断
43         var student = new Student();
44         // 2、局部变量类型定义
45         Student.show();
46         // 3、局部变量类型增量for循环的使用
47         showList();
48         // 4、局部变量类型的普通for循环的使用
49         showArray();
50         // 5、Lanbda表达式，函数式编程，局部变量的定义
51         var read = new Thread(() -> System.out.println("Lanbda表达式的推断，局部变量定义"));
52         System.out.println(read.getName());
53     }
54 
55 }

2、Java1.8特性，Java 8的一个大亮点是引入函数式编程即Lambda表达式，使用它设计的代码会更加简洁。当开发者在编写Lambda表达式时，也会随之被编译成一个函数式接口。下面这个例子就是使用Lambda语法来代替匿名的内部类，代码不仅简洁，而且还可读。（如果学习了Scala语言，会发现Scala语言很简洁，Spark就是用Scala开发的。）。

 1 package com.bie.lesson1;
 2 
 3 /**
 4  * 
 5  * @author biehl
 6  *
 7  */
 8 public interface Calculator {
 9 
10     /**
11      * result the a add b
12      * @param a
13      * @param b
14      * @return
15      */
16     int add(int a,int b);
17 }

下面使用Lanbda是学习的重点：

 1 package com.bie.lesson1;
 2 
 3 /**
 4  * 
 5  * @author biehl
 6  * @date: 2018年8月12日 下午4:15:39
 7  * @Description Java函数式编程之Lambda使用
 8  * 
 9  */
10 public class LanbdaLearn {
11 
12     /**
13      * use the Lanbda,a add b
14      * 
15      * @param a
16      * @param b
17      * @param calculator
18      */
19     public static void sum(int a, int b, Calculator calculator) {
20         int result = calculator.add(a, b);
21         System.out.println("result : " + result);
22     }
23 
24     public static void main(String[] args) {
25         // 局部变量类型推断
26         var sum1 = 100;
27         var sum2 = 200;
28         // 备注:小括号代表Caluator接口add抽象方法的参数,大括号代表 add 的方法体,注意方法体最后的;
29         sum(sum1, sum2, (int a, int b) -> {
30             return a + b;
31         });
32 
33         // Lanbda省略格式
34         // 可推导即可省略
35         // Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。
36         // 例如上例还可 以使用Lambda的省略写法：
37         sum(sum1, sum2, (a, b) -> a + b);
38 
39         // 省略规则
40         // 在Lambda标准格式的基础上，使用省略写法的规则为：
41         // 1.小括号内参数的类型可以省略；
42         // 2.如果小括号内有且仅有一个参，则小括号可以省略；
43         // 3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
44 
45     }
46 
47 }