观前提示：

本文所使用的IDEA版本为ultimate 2019.1，JDK版本为1.8.0_141。

1.简介

Java8，又称jdk1.8，是Oracle公司于2014年03月18日发布，名称为Spider。

2. 新特性

1. Lambda表达式
   Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。

2. 方法引用
   方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与Lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

3. 函数式接口
   函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

4. 默认方法
   默认方法就是一个在接口里面有了一个实现的方法。

5. Stream API
   新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。

6. Optional 类
   Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。

7. Nashorn, JavaScript 引擎
   Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。

8. Date Time API
   加强对日期与时间的处理。

9. Base64
   Java 8 内置了 Base64 编码的编码器和解码器。

2.1 Lambda表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

2.1.1 语法

(parameters) -> expression
或
(parameters) -> { statements; }

2.1.2 重要特征

1. 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

4. 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

2.1.3 例子

package testJava8;public class TestLambda {public static void main(String[] args) {// 声明类型，无大括号，无返回关键字MathOperation addition = (int a, int b) -> a + b;// 声明类型，有大括号，有返回关键字MathOperation subtraction = (int a, int b) -> {return a - b;};// 不声明类型，无大括号，无返回关键字MathOperation multiplication = (a, b) -> a * b;// 不声明类型，有大括号，有返回关键字MathOperation division = (a, b) -> {return a / b;};System.out.println(" 4 + 2 = " + addition.operate(4,2));System.out.println(" 4 - 2 = " + subtraction.operate(4,2));System.out.println(" 4 * 2 = " + multiplication.operate(4,2));System.out.println(" 4 / 2 = " + division.operate(4,2));}interface MathOperation{int operate(int a, int b);}
}

运行结果如下

2.1.4 注意

1. lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
   lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

2. 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

2.2 方法引用

方法引用通过方法的名字来指向一个方法。

方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

方法引用使用一对冒号 :: 。

2.2.1 语法

1. 构造器引用 ：Class::new

2. 静态方法引用：Class::static_method

3. 特定类的任意对象的方法引用：Class::method

4. 特定对象的方法引用：instance::method

2.2.2 例子

package testJava8;import java.util.ArrayList;
import java.util.List;public class TestMethodReference {public static void main(String[] args) {List<String> list = new ArrayList<>();list.add("a");list.add("b");list.add("c");// 静态方法引用list.forEach(System.out::println);}
}

运行结果

2.3 函数式接口

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

2.3.1 定义与实现

@FunctionalInterface
interface FunctionalInterface {void doSomething(String param);
}

使用Lambda表达式来实现接口

FunctionalInterface functionalInterface -> System.out.println("Param : " +  param);

2.3.2 已存在的函数式接口

JDK 1.8 之前已有的函数式接口:

1. java.lang.Runnable

2. java.util.concurrent.Callable

3. java.security.PrivilegedAction

4. java.util.Comparator

5. java.io.FileFilter

6. java.nio.file.PathMatcher

7. java.lang.reflect.InvocationHandler

8. java.beans.PropertyChangeListener

9. java.awt.event.ActionListener

10. javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

1. java.util.function

2.4.默认方法

默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。

只需在方法名前面加个 default 关键字即可实现默认方法。

2.4.1 语法

默认方法

public interface DefaultFunctionInterface {default void doSomething(){System.out.println("...");}
}

静态默认方法

public interface DefaultFunctionInterface {static void doSomething(){System.out.println("...");}
}

2.4.2 例子

package testJava8;public class TestDefaultFunction {public static void main(String[] args) {Animal animal = new Dog();animal.print();}
}interface Animal{default void print(){System.out.println("这是动物");}static void say(){System.out.println("动物叫");}
}class Dog implements Animal{public void print(){Animal.super.print();Animal.say();}
}

测试结果

2.5 Stream API

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream（流）是一个来自数据源的元素队列并支持聚合操作

1. 元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。

2. 数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。

3. 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。和以前的Collection操作不同， Stream操作还有两个基础的特征：

4. Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。

5. 内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

以上的流程转换为 Java 代码为：

List<Integer> transactionsIds = 
widgets.stream().filter(b -> b.getColor() == RED).sorted((x,y) -> x.getWeight() - y.getWeight()).mapToInt(Widget::getWeight).sum();

2.5.1 生成流

有两个方法来实现流

1. stream() − 为集合创建串行流。

2. parallelStream() − 为集合创建并行流。

package testJava8;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// streamList<String> notNullList = strList.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());System.out.println(notNullList.toString());}
}

结果为

2.5.2 forEach

Stream 提供了方法 ‘forEach’ 来迭代流中的每个数据。

package testJava8;import java.util.Arrays;
import java.util.List;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// forEachstrList.forEach(System.out::println);}
}

结果为

2.5.3 map

map 方法用于映射每个元素到对应的结果

package testJava8;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// mapList newList = strList.stream().map(str -> str + "i").collect(Collectors.toList());System.out.println(newList.toString());}
}

结果为

2.5.4 filter

filter 方法用于通过设置的条件过滤出元素。

package testJava8;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// filterList<String> notNullList = strList.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());System.out.println(notNullList.toString());}
}

结果为

2.5.5 limit

limit 方法用于获取指定数量的流。

package testJava8;import java.util.Arrays;
import java.util.List;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// limitstrList.stream().limit(3).forEach(System.out::println);}
}

结果为

2.5.6 sorted

sorted 方法用于对流进行排序。

package testJava8;import java.util.Arrays;
import java.util.List;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// sortstrList.stream().sorted().forEach(System.out::println);}
}

结果为

2.5.7 并行（parallel）程序

parallelStream 是流并行处理程序的代替方法。

package testJava8;import java.util.Arrays;
import java.util.List;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// parallelStreamlong count = strList.parallelStream().filter(str -> !str.isEmpty()).count();System.out.println(count);}
}

结果为

2.5.8 Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。

package testJava8;import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;public class TestStream {public static void main(String[] args) {List<String> strList = Arrays.asList("abcd", "123", "cde", "b456", "", "ghj");// CollectorsList<String> notNullList = strList.stream().filter(str -> !str.isEmpty()).collect(Collectors.toList());System.out.println(notNullList.toString());String merge = strList.stream().filter(str -> !str.isEmpty()).collect(Collectors.joining(", "));System.out.println(merge);}
}

结果为

2.5.9 统计

package testJava8;import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;public class TestStream {public static void main(String[] args) {// statsList<Integer> numberList = Arrays.asList(3, 8, 6, 7, 2, 9, 1);IntSummaryStatistics statistics = numberList.stream().mapToInt(x -> x).summaryStatistics();System.out.println("最大数：" + statistics.getMax());System.out.println("最小数：" + statistics.getMin());System.out.println("平均数：" + statistics.getAverage());System.out.println("和：" + statistics.getSum());}
}

结果为

2.6 Optional 类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

方法（以下截图来源于jdk1.8 api）

package testJava8;import java.util.Optional;public class TestOptional {public static void main(String[] args) {Integer i1 = null;Integer i2 = new Integer(3);// Optional.ofNullable允许空值Optional<Integer> o1 = Optional.ofNullable(i1);Optional<Integer> o2 = Optional.of(i2);System.out.println("第一个参数值存在：" + o1.isPresent());System.out.println("第二个参数值存在：" + o2.isPresent());// Optional.orElse 判断值是否存在，存在则返回它，否则返回默认值Integer v1 = o1.orElse(new Integer(0));System.out.println("第一个值为：" + v1);// Optional.get获取值Integer v2 = o2.get();System.out.println("第二个值为：" + v2);}
}

结果为

2.7 Nashorn, JavaScript 引擎

Nashorn 一个 javascript 引擎。

Nashorn JavaScript Engine 在 Java 15 已经不可用了。

从 JDK 1.8 开始，Nashorn取代Rhino(JDK 1.6, JDK1.7) 成为 Java 的嵌入式 JavaScript 引擎。Nashorn 完全支持 ECMAScript 5.1 规范以及一些扩展。它使用基于 JSR 292 的新语言特性，其中包含在 JDK 7 中引入的 invokedynamic，将 JavaScript 编译成 Java 字节码。

与先前的 Rhino 实现相比，这带来了 2 到 10倍的性能提升。

2.8 新的Date Time API

Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。

Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：

1. Local(本地) − 简化了日期时间的处理，没有时区的问题。

2. Zoned(时区) − 通过制定的时区处理日期时间。

2.8.1 本地化日期时间 API

LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。

package testJava8;import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;public class TestLocalDateTime {public static void main(String[] args) {LocalDateTime now = LocalDateTime.now();System.out.println("当前时间为：" + now);int year = now.getYear();Month month = now.getMonth();int day = now.getDayOfMonth();int hour = now.getHour();System.out.println("年：" + year + "，月：" + month + "，日：" + day + "，小时：" + hour);LocalDate d1 = now.toLocalDate();System.out.println("当前日期为：" + d1);LocalDateTime d2 = now.withDayOfMonth(12).withMonth(12).withYear(2019);System.out.println("2019年12月12日：" + d2);LocalDate d3 = LocalDate.of(2018, Month.JANUARY, 1);System.out.println("2018年1月1日：" + d3);LocalTime d4 = LocalTime.of(23, 59, 59);System.out.println("23点59分59秒：" + d4);LocalTime d5 = LocalTime.parse("01:01:01");System.out.println("1点1分1秒：" + d5);}
}

运行结果为

2.8.1 使用时区的日期时间API

如果我们需要考虑到时区，就可以使用时区的日期时间API。

package testJava8;import java.time.ZoneId;
import java.time.ZonedDateTime;public class TestZonedDateTime {public static void main(String[] args) {ZonedDateTime d1 = ZonedDateTime.now();System.out.println("当前时间为：" + d1);ZoneId zoneId = ZoneId.of("Asia/Shanghai");System.out.println("ZoneId : " + zoneId);ZoneId currentId = ZoneId.systemDefault();System.out.println("Current ZoneId : " + currentId);}
}

运行结果为

2.9 Base64

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

1. 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。

2. URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。

3. MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

package testJava8;import java.util.Base64;public class TestBase64 {private static String UTF8 = "UTF-8";public static void main(String[] args) throws Exception {// Base64 编码字符串 (基本)String baseStr = Base64.getEncoder().encodeToString("baseString".getBytes(UTF8));System.out.println("Base64 编码字符串 (基本) :" + baseStr);byte[] plainBytes = Base64.getDecoder().decode(baseStr);System.out.println("Base64 编码字符串 (基本) 原始字符串为：" + new String(plainBytes, UTF8));// Base64 编码字符串 (URL)String urlStr = Base64.getUrlEncoder().encodeToString("urlString".getBytes(UTF8));System.out.println("Base64 编码字符串 (URL) :" + urlStr);plainBytes = Base64.getDecoder().decode(urlStr);System.out.println("Base64 编码字符串 (URL)原始字符串为：" + new String(plainBytes, UTF8));// Base64 编码字符串 (MIME)String mimeStr = Base64.getMimeEncoder().encodeToString("mimeString".getBytes(UTF8));System.out.println("Base64 编码字符串 (MIME) :" + mimeStr);plainBytes = Base64.getDecoder().decode(mimeStr);System.out.println("Base64 编码字符串 (MIME) 原始字符串为：" + new String(plainBytes, UTF8));}
}

结果为