关于Java8的精心总结

前言

​ 最近公司里比较新的项目里面，看到了不少关于java8新特性的用法，因为以前本身对java8的新特性不是很了解也没有去作深刻研究，因此最近就系统的去学习了一下，而后总结了一篇文章第一时间和你们分享一下。

​

​ 在了解一项新技术以前，咱们须要了解咱们为何要去学习它以及它的优势，如下是我总结的：

Java8（又称jdk1.8）是java语言开发的一个主要版本，Java8是oracal公司于2014年3月发布，能够当作是自java5以来最具备革命性的版本。

新特性的优势：速度更快、代码更少、便于并行、最大化减小空指针异常

函数式编程提供了一种更高层次的抽象化

排序：

List<RoleEntity> rolesListSort = rolesList.stream().sorted(Comparator.comparing(RoleEntity::getCreateDate)).collect(Collectors.toList());

Consumer是一个函数式接口

参数是Consumer类型的，Consumer里面的泛型表示泛型的类型要么是Integer,要么是Integer的父类，super表示它及它上面的，也就是父类。

下面这段代码是在Iterable接口里面的默认方法，jdk8以后的新方法，默认方法（默认方法的引入很大程度上是为了保证向后兼容）

default void forEach(Consumer<? super T> action) {    
Objects.requireNonNull(action);        
for (T t : this) {           
action.accept(t);        
} 
}

关于Java8的新特性，我总结了如下6个方面，咱们能够从如下6个方面进行学习了解：

1、Lambda表达式

​ 个人理解lambbda表达式实际上是新的一套语法规则，主要是语法上面的要求。

那咱们为啥须要Lambda表达式？

在java中，咱们没法将函数做为参数传递给一个方法，也没法声明返回一个函数的方法；在JavaScript中，函数参数是一个函数，返回值是另外一个函数的状况是很是常见的；JavaScript是一门很是典型的函数式语言。

addUser（e -> Sysout.out.println("hello")）e表示参数，->箭头符号，表示分隔符，他的做用是分割左边和右边的。Sysout.out.println("hello")是执行体，也就是代码块（若是执行体里面不止一行代码，那就能够加上花括号括起来）因此Lambda表达式分为三部分

Lambda表达式的基本结构：

• 一个Lambda表达式能够有0个或多个参数，参数的类型能够明确声明，也能够经过上下文来推断。例如（int a）和（a）效果同样；
• 全部参数都必须包含在圆括号内，参数之间用逗号相隔；
• 空圆括号表明参数集为空。例如：（）-> 42
• 当只有一个参数，且其类型能够推导出时，圆括号（）能够省略。例如：a -> return a*a
• Lambda表达式的主体也就是body能够包含0条或多条语句。
• 若是表达式的主体只有一条语句，花括号{}能够省略，匿名函数的返回类型与该主体表达式一致
• 若是表达式的主体包含一条语句以上，则必须包含在花括号{}里面造成代码块。匿名函数的返回类型与该主体表达式一致，若没有返回则为空。
• statement和expression的区别，expression只有一句，不须要花括号包裹，不须要return；statement须要花括号包裹，且若是有返回值，必须return

（argument）-> {body}

也能够：

（arg1, arg2）-> {body}

（type arg1, type arg2）-> {body}（这个是最完整的语法）

（param1，param2，param3）-> {} 左边圆括号里面表示方法的参数 ，右边花括号里面表明方法的具体实现

（）-> {} 类型是经过上下文来推断的

实际就是去目标函数式接口里面去找那个特定的惟一的抽象方法，去看抽象方法里面的-参数和返回类型，而抽象方法的名字对于Lambda表达式来讲是毫无心义的

Lambda表达式的做用：

• Lambda表达式为Java添加了缺失的函数式编程特性，使咱们能将函数看成一等公民看待
• 在将函数做为一等公民的语言中，Lambda表达式的类型是函数。但在Java中，Lambda表达式是对象，他们必须依附于一类特别的对象类型——函数式接口（functional interface）
• 传递的是行为，而不只仅是值（在之前的方式中，是先定义好了行为（行为已经存在），而后再调用这个行为进行使用，而如今是相反，行为是提早并不存在，是经过方法的传递来进行告知的）

​

//内部迭代    integerList.forEach(new Consumer<Integer>() {  
//匿名内部类      @Override      public void accept(Integer integer) {        		     System.out.println(integer);      
}    
});

2、函数式（Functional）接口

​ 函数式接口是能够经过三种方式实现的：Lambda表达式、方法引用、构造器引用

经过Lambda表达式、方法引用或者构造器引用的来建立一个函数式接口的实例

关于函数式接口：

1. 若是一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2. 若是咱们在某个接口上声明了@FunctionalInterface注解，那么编译器就会按照函数式接口的定义来要求该接口。
3. 若是一个接口只有一个抽象方法，可是在该接口上并无声明@FunctionalInterface注解，那么编译器依旧会把该接口看做一个函数式接口

Java8里面引入的不少函数式接口它们都位于java.util.function下面。

如下是一些经常使用的函数式接口：

位于java.util.function这个包下面

Consumer消费者 接受一个参数，不返回结果

public interface Consumer { void accept(T t); }

Function，接受一个参数，返回一个结果

public interface Function<T, R> { R apply(T t); }

BiFunction接收两个参数，返回一个结果（其中BI是bidirectional的缩写，意思是双向）

public interface BiFunction<T, U, R> { R apply(T t, U u); }

Supplier 提供者，供应者，不接收任何参数，返回一个结果

public interface Supplier { T get(); }

Predicate谓语，接收一个参数，返回一个布尔值（根据给定的参数，返回布尔）

public interface Predicate { boolean test(T t); }

3、方法引用

方法引用是Lambda表达式的一种特殊状况（或者说是Lambda表达式的一个语法糖），能够理解为方法引用和Lambda表达式这两种方式所实现的功能其实同样的，彻底等价，可是方法引用的方式更简洁。

咱们能够将方法引用看做是一个函数指针（Function pointer）

方法引用（method references）：

List<Integer> integerList = Arrays.asList(1,2,3,4,5); //方法引用的方式 integerList.forEach(System.out::println);

方法引用有4种:

一、类名：：静态方法名

如下这两种形式是彻底不等价的

classname：：staticmethod（表示的是指向，函数指针的概念）

classname.staticmethod（真正表示的是方法调用的概念）

二、引用名（对象名）：：实例方法名

三、类名：：实例方法名

四、构造方法引用（constructor references）：类名：：new

4、强大的Stream API

其实就是JDK8提供给咱们新的API，常常和Lambda表达式和函数式接口一块儿使用

分为串行流和并行流

list.stream()串行流，只有一个线程，一个线程执行全部操做

list.parallelStream()并行流，多线程，分工合做

list.stream().map()：map此处的意思是映射的意思

Stream也是一个接口，里面的绝大多数方法都是高阶函数

Stream流，他是与Lambda表达式相伴相生的，经过流的方式咱们能够更好的操做集合

流的三部分构成：（SQL语句和流很是很是像）

一、源

二、零个或若干个中间操做（操做的是这个源，操做值的是过滤，排序，映射，分区等，这些操做自己有点像SQL语句）

三、终止操做

流操做分类：

一、惰性求值

二、及早求值

流的全部的中间操做方法都是lazy的（或者说是延迟的，或者说是惰性求值的），在没有遇到终止操做或者及早求值的操做的状况下，中间操做是不会被执行的，只有在遇到终止操做的时候，这若干个中间操做才会一并的执行

stream().xxx().zzz().count();

filter()用来判断里面的条件是真仍是假？若是是假，就从流当中过滤掉；若是是真，就继续放到流当中，供后续操做使用

流：

• Colletion提供了新的Stream()方法；
• 流不存储值，经过管道的方式获取值；
• 本质是函数式的，对流的操做会形成一个结果，不过并不会修改底层的数据源，集合能够做为流的底层数据源；
• 延迟查找，不少流操做（过滤，映射，排序，分区等）均可以延迟实现；

SQL语句是一种描述性的语言，只须要发送指令告诉底层须要作什么，而不关心底层是怎么实现的，而流其实也是同样的，只须要知道作什么，而不须要知道具体底层是怎么作的。

内部迭代和外部迭代本质刨析：（操做流就像英语中的完形填空，直接操做集合就是完成一个完整的命题做文）

内部迭代

用流，是并行化，如下代码可能你以为有多个循环，可是流的底层实际上只用了一个循环，能够这样想，流其实是一个容器，里面有一个集合，这个集合存放的是对流的各类操做，流会尽最大可能去优化；如下代码也不是按照顺序一个一个执行的，是由集合框架本身决定的

外部迭代

用集合，是串行化，下图是个人代码，能够帮助你们理解

集合关注的是数据与数据存储自己；

流关注的是对数据的计算；

流与迭代器相似的一点是：流是没法重复使用或消费的

如何判断是中间操做仍是终止操做呢

中间操做都会返回一个Stream对象，好比Stream ，Stream ，Stream

终止操做则不会返回Steam类型，可能不返回值，也可能返回其余类型的单个值

Stream流里面的方法：

int sum = Stream.iterate(1, item -> item + 2).limit(6).filter(item -> item > 2)            .mapToInt(item -> item * 2) .skip(2).limit(2).sum();

skip()：忽略掉前几个元素

limit()：获取前几个元素

sum()：求和（map映射是没有求和方法的）

Stream分组与分区(partition )：

分组：group by

分区：partition by （布尔值）

分区是分组的一种特殊状况

流的特性：

流一旦被操做或使用了，就不能再去重复的使用这个流，或者说流一旦被关闭了，也是不能再去重复使用了

5、Optional类

中文意思：可选

Optional类的使用其实在其余语言里很早就使用了（好比Swift、Groovy、Scala），Java是最晚使用的，

它的出现主要解决的问题：NPE（NullPointerException）

if (null != person){ Address address = person.getName(); if (null != address){ } }

6、高阶函数

高阶函数：若是一个函数接受一个函数做为参数，或者返回一个函数做为一个返回值，那么该函数就叫作高阶函数。

默认方法

接口当中能够声明方法的实现了，可是这个方法的实现必需要带上default关键字

从java8开始，为啥要增长默认方法？

Collector收集器（很重要）

<R, A> R collect(Collector<? super T, A, R> collector);

• collect：收集器
• Collector做为collect方法的参数
• Collector是一个接口，它是一个可变的汇聚操做，将输入元素累积到一个可变的结果容器中（ArrayList就是一个可变的容器），它会在全部元素处理完毕以后，将累积的结果转换成一个最终的表示（这是一个可选操做），它支持串行（一个线程执行）和并行（多个线程执行）两种方式执行。
• Collectors自己提供了关于Collector的常见汇聚实现，Collectors自己实际是一个工厂（Collectors提供了不少可变汇聚操做的实现）

public interface Collector<T, A, R>{ Supplier supplier(); BiConsumer<A, T> accumulator();//翻译成累加器 //将两个结果容器合并成一个（用于线程并发） BinaryOperator combiner();//结合器 Function<A, R> finisher();//完成器 }

Collector同一性和结合性分析

combiner函数：

Iterator迭代器

总结

​ 以上是我关于jdk1.8新特性的一些总结，欢迎你们相互交流。

---

公众号：良许Linux

有收获？但愿老铁们来个三连击，给更多的人看到这篇文章