JDK8的新特性

　　虽然JDK9已经出来了，可是jdk8一直没作过总结，在这里先对jdk8的新特性作一个总结，

　　由于有一些新的特性值得学习，是一个重大的升级，下面是一些参考的文章，由于会使得文档显得特别杂。

　　参考：http://www.importnew.com/11908.html

　　参考：https://www.ibm.com/developerworks/cn/java/j-lo-jdk8newfeature/

　　参考：http://blog.csdn.net/qiubabin/article/details/70256683

　　参考：http://blog.csdn.net/helloworldwt/article/details/52993661

　　参考：http://www.runoob.com/java/java8-new-features.html

一：概述

1.复制的一个结构图：

　　

 

2.主要特性

　　Lambda编程

　　函数式接口（包含在Lambda编程中）

　　流（Stream）

　　方法引用

　　默认方法

　　方法参数反射

　　日期时间改进 

 

二：Lambda编程

1.函数式编程

　　函数编程很是关键的几个特性以下：
　　（1）闭包与高阶函数
　　函数编程支持函数做为第一类对象，有时称为 闭包或者 仿函数（functor）对象。实质上，闭包是起函数的做用并能够像对象同样操做的对象。
与此相似，FP 语言支持 高阶函数。高阶函数能够用另外一个函数（间接地，用一个表达式） 做为其输入参数，在某些状况下，它甚至返回一个函数做为其输出参数。这两种结构结合在一块儿使得能够用优雅的方式进行模块化编程，这是使用 FP 的最大好处。
　　（2）惰性计算
　　在惰性计算中，表达式不是在绑定到变量时当即计算，而是在求值程序须要产生表达式的值时进行计算。延迟的计算使您能够编写可能潜在地生成无穷输出的函数。由于不会计算多于程序的其他部分所须要的值，因此不须要担忧由无穷计算所致使的 out-of-memory 错误。
　　（3）没有“反作用”
　　所谓"反作用"（side effect），指的是函数内部与外部互动（最典型的状况，就是修改全局变量的值），产生运算之外的其余结果。函数式编程强调没有"反作用"，意味着函数要保持独立，全部功能就是返回一个新的值，没有其余行为，尤为是不得修改外部变量的值。
　　综上所述，函数式编程能够简言之是： 使用不可变值和函数， 函数对一个值进行处理， 映射成另外一个值。这个值在面向对象语言中能够理解为对象，另外这个值还能够做为函数的输入。

 

2.官方的教程

　　https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

 

3.语法

　　完整的Lambda表达式由三部分组成：参数列表、箭头、声明语句；

　　    (Type1 param1, Type2 param2, ..., TypeN paramN) -> { statment1; statment2; //............. return statmentM;}

　　1. 绝大多数状况，编译器均可以从上下文环境中推断出lambda表达式的参数类型，因此参数能够省略：

　   　(param1,param2, ..., paramN) -> { statment1; statment2; //............. return statmentM;}

　　2.当lambda表达式的参数个数只有一个，能够省略小括号：

　   　param1 -> { statment1; statment2; //............. return statmentM;}

　　3.当lambda表达式只包含一条语句时，能够省略大括号、return和语句结尾的分号：

　　   param1 -> statment

 

3.扩展

　　这个时候JVM会自动计算表达式值并返回，另外这种形式还有一种更简写法，方法引用写法，具体能够看下面的方法引用的部分。

 

4.函数接口

　　函数接口是只有一个抽象方法的接口， 用做 Lambda 表达式的返回类型。
　　接口包路径为java.lang.function，而后接口类上面都有@FunctionalInterface这个注解。下面列举几个较常见的接口类。

　　这些函数接口在使用Lambda表达式时作为返回类型，JDK定义了不少如今的函数接口，实际本身也能够定义接口去作为表达式的返回，只是大多数状况下JDK定义的直接拿来就能够用了。并且这些接口在JDK8集合类使用流操做时大量被使用。

　　

 

5.类型检查，类型推断

　　Java编译器根据 Lambda 表达式上下文信息就能推断出参数的正确类型。 程序依然要通过类型检查来保证运行的安全性， 但不用再显式声明类型罢了。

　　这就是所谓的类型推断。Lambda 表达式中的类型推断， 其实是 Java 7 就引入的目标类型推断的扩展。

　　这个在上面已经提过：

　　

　　有时候显式写出类型更易读，有时候去掉它们更易读。

 

6.局部变量限制

　　Lambda表达式也容许使用自由变量（不是参数，而是在外层做用域中定义的变量），就像匿名类同样。 它们被称做捕获Lambda。 Lambda能够没有限制地捕获（也就是在其主体中引用）实例变量和静态变量。但局部变量必须显式声明为final，或事实上是final。
　　为何局部变量有这些限制？
　　（1）实例变量和局部变量背后的实现有一个关键不一样。实例变量都存储在堆中，而局部变量则保存在栈上。若是Lambda能够直接访问局部变量，并且Lambda是在一个线程中使用的，则使用Lambda的线程，可能会在分配该变量的线程将这个变量收回以后，去访问该变量。所以， Java在访问自由局部变量时，其实是在访问它的副本，而不是访问原始变量。若是局部变量仅仅赋值一次那就没有什么区别了——所以就有了这个限制。
　　（2）这一限制不鼓励你使用改变外部变量的典型命令式编程模式。

 

7.示例

 1 package com.lanmda.it;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 public class TestLambdaDemo1 {
 7 
 8     public static void main(String[] args) {
 9         List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
10         long num = list.stream().filter( a ->  a > 4 ).count();
11         System.out.println(num);
12     }
13 
14 }

 

8.效果

　　

 

9.程序

 1 package com.lanmda.it;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 public class TestLambdaDemo4 {
 7     //接口
 8     interface MathOperation {
 9           int operation(int a, int b);
10     }
11     interface GreetingService {
12           void sayMessage(String message);
13     }
14     //main
15     public static void main(String[] args) {
16         
17           // 类型声明
18           MathOperation addition = (int a, int b) -> a + b;
19             
20           // 不用类型声明
21           MathOperation subtraction = (a, b) -> a - b;
22             
23           // 大括号中的返回语句
24           MathOperation multiplication = (int a, int b) -> { return a * b; };
25             
26           // 没有大括号及返回语句
27           MathOperation division = (int a, int b) -> a / b;
28             
29           System.out.println("10 + 5 = " + operate(10, 5, addition));
30           System.out.println("10 - 5 = " + operate(10, 5, subtraction));
31           System.out.println("10 x 5 = " + operate(10, 5, multiplication));
32           System.out.println("10 / 5 = " + operate(10, 5, division));
33             
34           // 不用括号
35           GreetingService greetService1 = message -> System.out.println("Hello " + message);      
36           greetService1.sayMessage("Runoob"); 
37           
38           // 用括号
39           GreetingService greetService2 = (message) -> System.out.println("Hello " + message); 
40           greetService2.sayMessage("Google");
41        }
42                 
43        private static int operate(int a, int b, MathOperation mathOperation){
44           return mathOperation.operation(a, b);
45        }
46 
47 }

 

10.效果

　　

 

11.说明上面的程序

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，咱们使用各类类型的Lambda表达式来定义MathOperation接口的方法。而后咱们定义了sayMessage的执行。
• Lambda 表达式免去了使用匿名方法的麻烦，而且给予Java简单可是强大的函数化的编程能力。

 

三：流

1.介绍

　　流是Java API的新成员，它容许你以声明性方式处理数据集合（经过查询语句来表达，而不是临时编写一个实现）。就如今来讲，你能够把它们当作遍历数据集的高级迭代器。此外，流还能够透明地并行处理，你无需写任何多线程代码了！

 

2.使用

类别	方法名	方法签名	做用
筛选切片	filter	Stream<T> filter(Predicate<? super T> predicate)	过滤操做，根据Predicate判断结果保留为真的数据，返回结果仍然是流
	distinct	Stream<T> distinct()	去重操做，筛选出不重复的结果，返回结果仍然是流
	limit	Stream<T> limit(long maxSize)	截取限制操做，只取前 maxSize条数据，返回结果仍然是流
	skip	Stream<T> skip(long n)	跳过操做，跳过n条数据，取后面的数据，返回结果仍然是流
映射	map	<R> Stream<R> map(Function<? super T, ? extends R> mapper)	转化操做，根据参数T，转化成R类型，返回结果仍然是流
	flatMap	<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)	转化操做，根据参数T，转化成R类型流，这里会生成多个R类型流，返回结果仍然是流
匹配	anyMatch	boolean anyMatch(Predicate<? super T> predicate)	判断是否有一条匹配，根据Predicate判断结果中是否有一条匹配成功
	allMatch	boolean allMatch(Predicate<? super T> predicate)	判断是否全都匹配，根据Predicate判断结果中是否所有匹配成功
	noneMatch	boolean noneMatch(Predicate<? super T> predicate)	判断是否一条都不匹配，根据Predicate判断结果中是否全部的都不匹配
查找	findAny	Optional<T> findAny()	查找操做， 查询当前流中的任意元素并返回Optional
	findFirst	Optional<T> findFirst()	查找操做， 查询当前流中的第一个元素并返回Optional
归约	reduce	T reduce(T identity, BinaryOperator<T> accumulator);	归约操做，一样两个类型的数据进行操做后返回相同类型的结果。好比两个整数相加、相乘等。
	max	Optional<T> max(Comparator<? super T> comparator)	求最大值，根据Comparator计算的比较结果获得最大值
	min	Optional<T> min(Comparator<? super T> comparator)	求最小值，根据Comparator计算的比较结果获得最小值
汇总统计	collect	<R, A> R collect(Collector<? super T, A, R> collector)	汇总操做，汇总对应的处理结果。这里常常与
	count	long count()	统计流中数据数量
遍历	foreach	void forEach(Consumer<? super T> action)	遍历操做，遍历执行Consumer 对应的操做

 

3.Stream API说明

　　上面是Stream API的一些经常使用操做，按场景结合lambda表达式调用对应方法便可。至于Stream的生成方式，Stream的of方法或者Collection接口实现类的stream方法均可以得到对应的流对象，再进一步根据须要作对应处理。

　　另外上述方法若是返回是Stream对象时是能够链式调用的，这个时候这个操做只是声明或者配方，不产生新的集合，这种类型的方法是惰性求值方法；有些方法返回结果非Stream类型，则是及早求值方法。

　　“为何要区分惰性求值和及早求值？ 只有在对须要什么样的结果和操 做有了更多了解以后， 才能更有效率地进行计算。 例如， 若是要找出大于 10 的第一个数字， 那么并不须要和全部元素去作比较， 只要找出第一个匹配的元素就够了。 这也意味着能够在集合类上级联多种操做， 但迭代只需一次。这也是函数编程中惰性计算的特性，即只在须要产生表达式的值时进行计算。这样代码更加清晰，并且省掉了多余的操做。

 

4.Optional与Collector说明

　　Optional类是为了解决常常遇到的NullPointerException出现的，这个类是一个可能包含空值的容器类。用Optional替代null能够显示说明结果可能为空或不为空，再使用时使用isPresent方法判断就能够避免直接调用的空指针异常。

　　Collectors类是一个很是有用的是归约操做工具类，工具类中的方法常与流的collect方法结合使用。好比
groupingBy方法能够用来分组，在转化Map时很是实用；partitioningBy方法能够用来分区（分区能够当作一种特殊的分组，真假值分组），joining方法能够用来链接，这个应用在好比字符串拼接的场景。

 

5.并行流

　　Collection接口的实现类调用parallelStream方法就能够实现并行流，相应地也得到了并行计算的能力。或者Stream接口的实现调用parallel方法也能够获得并行流。并行流实现机制是基于fork/join 框架，将问题分解再合并处理。

 

6.影响并行与串行性能的因素

　　（1）数据大小输入数据的大小会影响并行化处理对性能的提高。 将问题分解以后并行化处理， 再将结果合并会带来额外的开销。 所以只有数据足够大、 每一个数据处理管道花费的时间足够多
时， 并行化处理才有意义。
　　（2） 源数据结构
每一个管道的操做都基于一些初始数据源， 一般是集合。 将不一样的数据源分割相对容易，这里的开销影响了在管道中并行处理数据时到底能带来多少性能上的提高。
　　（3） 装箱
处理基本类型比处理装箱类型要快。
　　（4） 核的数量
极端状况下， 只有一个核， 所以彻底不必并行化。 显然， 拥有的核越多， 得到潜在性能提高的幅度就越大。 在实践中， 核的数量不单指你的机器上有多少核， 更是指运行时你的机器能使用多少核。 这也就是说同时运行的其余进程， 或者线程关联性（ 强制线程在某些核或 CPU 上运行） 会影响性能。
　　（5） 单元处理开销
好比数据大小， 这是一场并行执行花费时间和分解合并操做开销之间的战争。 花在流中
每一个元素身上的时间越长， 并行操做带来的性能提高越明显

 

四：方法引用

1.介绍

　　方法引用的基本思想是，若是一个Lambda表明的只是“直接调用这个方法”，那最好仍是用名称来调用它，而不是去描述如何调用它。事实上，方法引用就是让你根据已有的方法实现来建立Lambda表达式。可是，显式地指明方法的名称，你的代码的可读性会更好。因此方法引用只是在内容中只有一个表达式的简写。

　　当 你 需 要使用 方 法 引用时 ， 目 标引用 放 在 分隔符::前 ，方法 的 名 称放在 后 面 ，即ClassName :: methodName 。例如 ，Apple::getWeight就是引用了Apple类中定义的方法getWeight。请记住，不须要括号，由于你没有实际调用这个方法。方法引用就是Lambda表达式(Apple a) -> a.getWeight()的快捷写法。

　　这里有种状况须要特殊说明，就是类的构造函数状况，这个时候是经过ClassName::new这种形式建立Class构造函数对应的引用

　　

 

五：默认方法

1.介绍

　　为了以兼容方式改进API，Java 8中加入了默认方法。主要是为了支持库设计师，让他们可以写出更容易改进的接口。具体写法是在接口中加default关键字修饰。

 

2.说明

　　默认方法因为是为了不兼容方式改进API才引入，因此通常正常开发中不会使用，除非你也想改进API，而不影响老的接口实现。固然在JDK8有大量的地方用到了默认方法，因此对这种写法有必定的了解仍是有帮助的。
　　采用默认方法以后，你能够为这个方法提供一个默认的实现，这样实体类就无需在本身的实现中显式地提供一个空方法，而是默认就有了实现。

　　

3.优先级

　　因为类能够实现多个接口，也能够继承类，当接口或类中有相同函数签名的方法时，这个时候到底使用哪一个类或接口的实现呢？
这里有三个规则能够进行判断：
　　(1) 类中的方法优先级最高。类或父类中声明的方法的优先级高于任何声明为默认方法的优先级。
　　(2) 若是没法依据第一条进行判断，那么子接口的优先级更高：函数签名相同时，优先选择拥有最具体实现的默认方法的接口，即若是B继承了A，那么B就比A更加具体。
　　(3) 最后，若是仍是没法判断，继承了多个接口的类必须经过显式覆盖和调用指望的方法，显式地选择使用哪个默认方法的实现。否则编译都会报错。

 

六：方法参数反射

1.说明　　

　　JDK8 新增了Method.getParameters方法，能够获取参数信息，包括参数名称。不过为了不.class文件由于保留参数名而致使.class文件过大或者占用更多的内存，另外也避免有些参数（ secret/password）泄露安全信息，JVM默认编译出的class文件是不会保留参数名这个信息的。

　　这一选项需由编译开关 javac -parameters 打开，默认是关闭的。

　　

 

七：日期时间改进

1.说明

　　1.8以前JDK自带的日期处理类很是不方便，咱们处理的时候常常是使用的第三方工具包，好比commons-lang包等。不过1.8出现以后这个改观了不少，好比日期时间的建立、比较、调整、格式化、时间间隔等。
　　这些类都在java.time包下。比原来实用了不少。

 

2.LocalDate/LocalTime/LocalDateTime

　　LocalDate为日期处理类、LocalTime为时间处理类、LocalDateTime为日期时间处理类，方法都相似，具体能够看API文档或源码，选取几个表明性的方法作下介绍。

　　now相关的方法能够获取当前日期或时间，of方法能够建立对应的日期或时间，parse方法能够解析日期或时间，get方法能够获取日期或时间信息，with方法能够设置日期或时间信息，plus或minus方法能够增减日期或时间信息；

　　

3.TemporalAdjusters

　　这个类在日期调整时很是有用，好比获得当月的第一天、最后一天，当年的第一天、最后一天，下一周或前一周的某天等。

 

4.DateTimeFormatter

　　之前日期格式化通常用SimpleDateFormat类，可是不怎么好用，如今1.8引入了DateTimeFormatter类，默认定义了不少常量格式（ISO打头的），在使用的时候通常配合LocalDate/LocalTime/LocalDateTime使用，好比想把当前日期格式化成yyyy-MM-dd hh:mm:ss的形式:

 1 package com.lanmda.it;
 2 
 3 import java.time.LocalDateTime;
 4 import java.time.format.DateTimeFormatter;
 5 import java.util.Arrays;
 6 import java.util.List;
 7 
 8 public class TestLambdaDemo2 {
 9 
10     public static void main(String[] args) {
11         LocalDateTime dt = LocalDateTime.now();  
12         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");         
13         System.out.println(dtf.format(dt));  
14     }
15 
16 }

　　效果：

　　

 

八：JDK8的风格

1.程序

 1 package com.lanmda.it;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 import java.util.List;
 7 
 8 public class TestLambdaDemo3 {
 9 
10     public static void main(String[] args) {
11         List<String> names1 = new ArrayList<String>();
12           names1.add("Google ");
13           names1.add("Runoob ");
14           names1.add("Taobao ");
15           names1.add("Baidu ");
16           names1.add("Sina ");
17             
18           List<String> names2 = new ArrayList<String>();
19           names2.add("Google ");
20           names2.add("Runoob ");
21           names2.add("Taobao ");
22           names2.add("Baidu ");
23           names2.add("Sina ");
24            
25           System.out.println("使用 Java 7 语法: ");        
26           sortUsingJava7(names1);
27           System.out.println(names1);
28           
29           System.out.println("使用 Java 8 语法: ");
30           sortUsingJava8(names2);
31           System.out.println(names2);
32        }
33        
34        // 使用 java 7 排序
35        private static void sortUsingJava7(List<String> names){   
36           Collections.sort(names, new Comparator<String>() {
37              @Override
38              public int compare(String s1, String s2) {
39                 return s1.compareTo(s2);
40              }
41           });
42        }
43        
44        // 使用 java 8 排序
45        private static void sortUsingJava8(List<String> names){
46           Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
47        }
48 }

 

2.效果

　　

 

九：