能坚持别人不能坚持的，才能拥有你想拥有的。
关注编程大道，让我们一起成长
哈喽，大家好，我是walking，今天我们说说Java 8的新特性。
Java 8从发布到现在已经6年多了，java 8在Java历史版本中是一个具有“里程碑”意义的重要版本，相信现在很多公司都用上了Java 8这个版本，用了之后你就知道为什么说是“里程碑”了，然后你会觉得“真香”！
但是事情总不是那么绝对，我相信目前还有很多公司依然在用java 7甚至是java 6，相信也会有很多小伙伴即便是用上了java 8但是却还不知道它到底有哪些新的特性，那么今天就和大家一块看下java 8比起以往的版本到底有哪些新的特性。（文章内容过长，建议收藏）
Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的Stream API 等。
0、新特性
Java8 新增了非常多的特性，我们主要讨论以下几个：
-
Lambda 表达式 − Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。
-
方法引用 − 方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
-
默认方法 − 默认方法就是一个在接口里面有了一个实现的方法。
-
新工具 − 新的编译工具，如：Nashorn引擎 jjs、 类依赖分析器jdeps。
-
Stream API −新添加的Stream API（java.util.stream） 把真正的函数式编程风格引入到Java中。
-
Date Time API − 加强对日期与时间的处理。
-
Optional 类 − Optional 类已经成为 Java 8 类库的一部分，用来解决空指针异常。
-
Nashorn, JavaScript 引擎 − Java 8提供了一个新的Nashorn javascript引擎，它允许我们在JVM上运行特定的javascript应用。
新的编码风格
Java 8 希望有自己的编程风格，并与 Java 7 区别开，以下实例展示了 Java 7 和 Java 8 的编程格式：
public class NewStyle {
public static void main(String args[]) {
List<String> names1 = Arrays.asList("TianMao", "CaiNiao", "TaoBao", "HeMa", "XianYu", "FeiZhu");
List<String> names2 = Arrays.asList("TianMao", "CaiNiao", "TaoBao", "HeMa", "XianYu", "FeiZhu");
System.out.println("使用 Java 7 语法: ");
sortUsingJava7(names1);
System.out.println(names1);
System.out.println("使用 Java 8 语法: ");
sortUsingJava8(names2);
System.out.println(names2);
}
// 使用 java 7 排序
private static void sortUsingJava7(List<String> names) {
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
});
}
// 使用 java 8 排序
private static void sortUsingJava8(List<String> names) {
Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
}
}
执行以上代码：
使用 Java 7 语法:
[CaiNiao, FeiZhu, HeMa, TaoBao, TianMao, XianYu]
使用 Java 8 语法:
[CaiNiao, FeiZhu, HeMa, TaoBao, TianMao, XianYu]
1、lambda表达式
1.1 用法
什么是lambda表达式，看下面的代码就知道了，首先对比我们之前的代码，创建线程对象时需要传入一个实现 Runnable 接口的对象，以往我们都是 new 一个 Runnable 对象然后实现接口的 run 方法（匿名内部类），那是用java8的lambda表达式就简洁多了，往下看，t2和t3的写法，这就是lambda表达式的写法。
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("t1 ==> old");
}
});
Thread t2 = new Thread(()->System.out.println("t2 ==> lambda"));
Thread t3 = new Thread(()-> {
System.out.println("t3 ==> lambda");
System.out.println("more code");
});
}
我们来细看一下， Thread t2 = new Thread(()->System.out.println("t2 ==> lambda")); 其中的 ()->System.out.println("t2 ==> lambda") 这句代码，我们来解释一下， () 是你要实现的方法的参数名列表，注意是参数名，不用指定参数类型，如果没有参数就写一个空括号。（可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。）
对别t2和t3，当实现方法内部只有一行代码时可以直接写，如果多行代码，使用代码块的方式用{}包裹住，这是lambda的语法规定的。（可选的大括号：如果主体包含了一个语句，就不需要使用大括号）
再看一下下面的代码
public class Tester{
public static void main(String[] args) {
String str = "print content";
Printer p1 = content -> System.out.println(content);
p1.doPrint(str);
Printer p2 = (String content) -> System.out.println(content);
p2.doPrint(str);
}
}
interface Printer{
void doPrint(String content);
}
其中 content -> System.out.println(content) ，前面的content变量名没有用()包裹，这是因为lambda其中一个特性，即，可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
当然等价于(String content) -> System.out.println(content)（可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。）
再看一下下面的代码
public class Tester{
public static void main(String[] args) {
Judge judge = ()->1>2;
Judge judge2 = ()->{
System.out.println("judge...");
return 1>2;
};
}
}
interface Judge{
boolean doJudge();
}
我们定义的接口方法 doJudge() 返回参数是 boolean ，我们在实现接口方法是是这样写的， ()->1>2 ，不需要特别写 return 关键字，因为我们的表达式 1>2 的结果和该方法的返回类型一样，编译器会自动返回。（可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值，否则需要显示返回值。）
总结一下Lambda的重要特征:
• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值，否则需要显示返回值。
使用 Lambda 表达式需要注意以下两点：
• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
• Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。
1.2 变量作用域
lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义），否则会报错
访问成员变量则没有这种限制，不必为final
在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量，否则编译不通过
2、方法引用
2.1 介绍
方法引用通过方法的名字来指向一个方法。
方法引用可以使语言的构造更紧凑简洁，减少冗余代码。
方法引用使用一对冒号 :: 。
2.2 用法
下面，我们在 Sky 类中定义了 4 个方法作为例子来区分 Java 中 4 种不同方法的引用。
@FunctionalInterface
public interface Supplier<T> {
T get();
}
class Sky {
private String color;
//Supplier是jdk1.8的接口，这里和lambda一起使用了
public static Sky create(final Supplier<Sky> supplier) {
return supplier.get();
}
//静态方法，有参
public static void collide(final Sky car) {
System.out.println("Collided " + car.toString());
}
//成员方法，有参
public void follow(final Sky another) {
System.out.println("Following the " + another.toString());
}
//成员方法，无参
public void repair() {
System.out.println("Repaired " + this.toString());
}
//getter and setter
//toString
}
我们来看一下怎么用的
public static void main(String[] args) {
//构造器引用：它的语法是Class::new，或者更一般的Class< T >::new实例如下：
final Sky sky = Sky.create( Sky::new );
sky.setColor("red");
final List<Sky> skys = Arrays.asList(sky);
//静态方法引用：它的语法是Class::static_method，实例如下：
skys.forEach(Sky::collide);
//特定类的任意对象的方法引用：它的语法是Class::method实例如下：
skys.forEach(Sky::repair);
//特定对象的方法引用：它的语法是instance::method实例如下：
final Sky sky2 = Sky.create(Sky::new);
skys.forEach(sky2::follow);
}
final Sky sky= Sky.create(Sky::new)等价于final Sky sky1= Sky.create(()->new Sky());
3、函数式接口
3.1 介绍
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。
如定义了一个函数式接口如下：
@FunctionalInterface
interface Animal{
void barks();
}
那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：Animal cat= ()-> System.out.println("miao miao~");
函数式接口可以对现有的函数友好地支持 lambda。
JDK 1.8 之前已有的函数式接口:
• java.lang.Runnable
• java.util.concurrent.Callable
• java.security.PrivilegedAction
• java.util.Comparator
• java.io.FileFilter
• java.nio.file.PathMatcher
• java.lang.reflect.InvocationHandler
• java.beans.PropertyChangeListener
• java.awt.event.ActionListener
• javax.swing.event.ChangeListener
JDK 1.8 新增加了很多函数接口，主要在 java.util.function 包下，用来支持 Java的 函数式编程，该包中的函数式接口有：
| 序号 | 接口 & 描述 |
| 1 | BiConsumer<T,U>
代表了一个接受两个输入参数的操作，并且不返回任何结果 |
| 2 | BiFunction<T,U,R>
代表了一个接受两个输入参数的方法，并且返回一个结果 |
| 3 | BinaryOperator<T>
代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果 |
| 4 | BiPredicate<T,U>
代表了一个两个参数的boolean值方法 |
| 5 | BooleanSupplier
代表了boolean值结果的提供方 |
| 6 | Consumer<T>
代表了接受一个输入参数并且无返回的操作 |
| 7 | DoubleBinaryOperator
代表了作用于两个double值操作符的操作，并且返回了一个double值的结果。 |
| 8 | DoubleConsumer
代表一个接受double值参数的操作，并且不返回结果。 |
| 9 | DoubleFunction<R>
代表接受一个double值参数的方法，并且返回结果 |
| 10 | DoublePredicate
代表一个拥有double值参数的boolean值方法 |
| 11 | DoubleSupplier
代表一个double值结构的提供方 |
| 12 | DoubleToIntFunction
接受一个double类型输入，返回一个int类型结果。 |
| 13 | DoubleToLongFunction
接受一个double类型输入，返回一个long类型结果 |
| 14 | DoubleUnaryOperator
接受一个参数同为类型double,返回值类型也为double 。 |
| 15 | Function<T,R>
接受一个输入参数，返回一个结果。 |
| 16 | IntBinaryOperator
接受两个参数同为类型int,返回值类型也为int 。 |
| 17 | IntConsumer
接受一个int类型的输入参数，无返回值 。 |
| 18 | IntFunction<R>
接受一个int类型输入参数，返回一个结果 。 |
| 19 | IntPredicate
：接受一个int输入参数，返回一个布尔值的结果。 |
| 20 | IntSupplier
无参数，返回一个int类型结果。 |
| 21 | IntToDoubleFunction
接受一个int类型输入，返回一个double类型结果 。 |
| 22 | IntToLongFunction
接受一个int类型输入，返回一个long类型结果。 |
| 23 | IntUnaryOperator
接受一个参数同为类型int,返回值类型也为int 。 |
| 24 | LongBinaryOperator
接受两个参数同为类型long,返回值类型也为long。 |
| 25 | LongConsumer
接受一个long类型的输入参数，无返回值。 |
| 26 | LongFunction<R>
接受一个long类型输入参数，返回一个结果。 |
| 27 | LongPredicate
R接受一个long输入参数，返回一个布尔值类型结果。 |
| 28 | LongSupplier
无参数，返回一个结果long类型的值。 |
| 29 | LongToDoubleFunction
接受一个long类型输入，返回一个double类型结果。 |
| 30 | LongToIntFunction
接受一个long类型输入，返回一个int类型结果。 |
| 31 | LongUnaryOperator
接受一个参数同为类型long,返回值类型也为long。 |
| 32 | ObjDoubleConsumer<T>
接受一个object类型和一个double类型的输入参数，无返回值。 |
| 33 | ObjIntConsumer<T>
接受一个object类型和一个int类型的输入参数，无返回值。 |
| 34 | ObjLongConsumer<T>
接受一个object类型和一个long类型的输入参数，无返回值。 |
| 35 | Predicate<T>
接受一个输入参数，返回一个布尔值结果。 |
| 36 | Supplier<T>
无参数，返回一个结果。 |
| 37 | ToDoubleBiFunction<T,U>
接受两个输入参数，返回一个double类型结果 |
| 38 | ToDoubleFunction<T>
接受一个输入参数，返回一个double类型结果 |
| 39 | ToIntBiFunction<T,U>
接受两个输入参数，返回一个int类型结果。 |
| 40 | ToIntFunction<T>
接受一个输入参数，返回一个int类型结果。 |
| 41 | ToLongBiFunction<T,U>
接受两个输入参数，返回一个long类型结果。 |
| 42 | ToLongFunction<T>
接受一个输入参数，返回一个long类型结果。 |
| 43 | UnaryOperator<T>
接受一个参数为类型T,返回值类型也为T。 |
3.2 用法
Predicate接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。
该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。
该接口用于测试对象是 true 或 false。
我们可以通过以下实例（Java8Tester.java）来了解函数式接口 Predicate的使用：
public class Java8Tester {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// Predicate<Integer> predicate = n -> true
// n 是一个参数传递到 Predicate 接口的 test 方法
// n 如果存在则 test 方法返回 true
System.out.println("输出所有数据:");
eval(list, n -> true);
// Predicate<Integer> predicate1 = n -> n%2 == 0
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n%2 为 0 test 方法返回 true
System.out.println("输出所有偶数:");
eval(list, n -> n % 2 == 0);
// Predicate<Integer> predicate2 = n -> n > 3
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n 大于 3 test 方法返回 true
System.out.println("输出大于 3 的所有数字:");
eval(list, n -> n > 3);
}
public static void eval(List<Integer> list, Predicate<Integer> predicate) {
for (Integer n : list) {
if (predicate.test(n)) {
System.out.print(n + " ");
}
}
System.out.println();
}
}
输出
输出所有数据:
1 2 3 4 5 6 7 8 9
输出所有偶数:
2 4 6 8
输出大于 3 的所有数字:
4 5 6 7 8 9
4、默认方法
4.1 介绍
Java 8 新增了接口的默认方法。简单来说，默认方法就是接口定义的方法可以有一个默认的实现，而且不需要实现类去实现其方法。我们只需在方法名前面加个 default 关键字即可实现默认方法。
为什么要有这个特性？
首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。
4.2 用法
默认方法语法格式如下：
public interface Car {
default void print(){
System.out.println("我是一辆汽车!");
}
}
多个默认方法
一个接口有默认方法，考虑这样的情况，一个类实现了多个接口，且这些接口有相同的默认方法，以下实例说明了这种情况的解决方法：
public interface Car {
default void print(){
System.out.println("我是一辆汽车!");
}
}
public interface ElectricallyDriven {
default void print(){
System.out.println("我需要电力驱动!");
}
}
第一个解决方案是创建自己的默认方法，来覆盖重写接口的默认方法：
public class ElectricallyDrivenCar implements Car, ElectricallyDriven {
default void print(){
System.out.println("我是一辆电动汽车!");
}
}
第二种解决方案可以使用 super 来调用指定接口的默认方法：
public class ElectricallyDrivenCar implements Car, ElectricallyDriven {
public void print(){
ElectricallyDriven.super.print();
}
}
静态默认方法
Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：
public interface Car {
default void print(){
System.out.println("我是一辆汽车!");
}
// 静态方法
static void blowHorn(){
System.out.println("按喇叭!!!");
}
}
默认方法实例
我们可以通过以下代码来了解关于默认方法的使用，可以将代码放入 DefaultMethodTest.java 文件中：
public class DefaultMethodTest {
public static void main(String args[]){
Car electricallyDrivenCar = new ElectricallyDrivenCar();
electricallyDrivenCar.print();
System.out.println("=================");
Car.blowHorn();
}
}
interface Car {
default void print(){
System.out.println("我是一辆汽车!");
}
static void blowHorn(){
System.out.println("按喇叭!!!");
}
}
interface ElectricallyDriven {
default void print(){
System.out.println("我需要电力驱动!");
}
}
class ElectricallyDrivenCar implements Car, ElectricallyDriven {
public void print(){
Car.super.print();
ElectricallyDriven.super.print();
Car.blowHorn();
System.out.println("我是一辆电力驱动的汽车!");
}
}
执行以上脚本，输出结果为：
我是一辆汽车!
我需要电力驱动!
按喇叭!!!
我是一辆电力驱动的汽车!
=================
按喇叭!!!
5、Optional
5.1 介绍
Optio是一种容器对象，它内部可以认为只有一个字段，那就是你传入的值，这个值可以为空也可以不为空，这个类可以理解为是一个包装类，内部提供了很多判断和操作目标对象的方法。
例如，isPresent()方法，如果值存在则该方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，帮我们很好的解决空指针异常，这样我们就不用显式进行空值检测。
5.2 类方法
以下是Optional的方法：
| 序号 | 方法 & 描述 |
| 1 | static <T> Optional<T> empty()
返回空的 Optional 实例。 |
| 2 | boolean equals(Object obj)
判断其他对象是否等于 Optional。 |
| 3 | Optional<T> filter(Predicate<? super <T> predicate)
如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。 |
| 4 | <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)
如果值存在，返回基于Optional包含的映射方法的值，否则返回一个空的Optional |
| 5 | T get()
如果在这个Optional中包含这个值，返回值，否则抛出异常：NoSuchElementException |
| 6 | int hashCode()
返回存在值的哈希码，如果值不存在 返回 0。 |
| 7 | void ifPresent(Consumer<? super T> consumer)
如果值存在则使用该值调用 consumer , 否则不做任何事情。 |
| 8 | boolean isPresent()
如果值存在则方法会返回true，否则返回 false。 |
| 9 | <U>Optional<U> map(Function<? super T,? extends U> mapper)
如果有值，则对其执行调用映射函数得到返回值。如果返回值不为 null，则创建包含映射返回值的Optional作为map方法返回值，否则返回空Optional。 |
| 10 | static <T> Optional<T> of(T value)
返回一个指定非null值的Optional。 |
| 11 | static <T> Optional<T> ofNullable(T value)
如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。 |
| 12 | T orElse(T other)
如果存在该值，返回值， 否则返回 other。 |
| 13 | T orElseGet(Supplier<? extends T> other)
如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。 |
| 14 | <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常 |
| 15 | String toString()
返回一个Optional的非空字符串，用来调试 |
5.3 用法
public class User{
String name;
int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
//equals and toString
}
我们先来看一下of() 、ofNullable() 、equals() 、toString()方法
public static void main(String args[]) {
User walking = new User("walking", 18);
User walking2 = new User("walking", 18);
//of 返回一个指定非null值的Optional。如果传递的参数是 null，抛出异常 NullPointerException
Optional<User> walkingOp = Optional.of(walking);
//ofNullable 如果为非空，返回 Optional 描述的指定值，否则返回空的 Optional。允许传递为 null 参数
Optional<User> walking2Op = Optional.ofNullable(walking2);
//equals 判断其他对象是否等于 Optional
boolean equals = walkingOp.equals(walking2Op);
System.out.println("两个optional的值是否一样：" + equals);
//toString 返回一个Optional的非空字符串，用来调试
System.out.println("Optional的toString:" + walkingOp.toString());
}
控制台输出：
两个optional的值是否一样：true
Optional的toString:Optional[User{name='walking', age=18}]
我们再来看一下filter()，isPresent()，ifPresent(Consumer<? super T> consumer)方法
public static void main(String args[]) {
Optional<User> walkingOp = Optional.of(new User("walking", 18));
//filter 如果值存在，并且这个值匹配给定的 predicate，返回一个Optional用以描述这个值，否则返回一个空的Optional。
Optional<User> userOptional = walkingOp.filter(user -> user.age == 30);
System.out.println("filter后:" + userOptional.toString());
//isPresent 如果值存在则方法会返回true，否则返回 false。
System.out.println("是否匹配:" + userOptional.isPresent());
//ifPresent 如果值存在则使用该值调用 consumer , 否则不做任何事情。
userOptional.ifPresent(user -> System.out.println("user==>" + user));
}
控制台输出：
filter后:Optional.empty
是否匹配:false
以上代码可以判断Optional中的值是否满足我们filter的条件，很显然isPresent()返回false即不满足filter中的条件，所以ifPresent(Consumer<? super T> consumer)中传入的函数也就不会执行。
然后再看一下map()方法
public static void main(String args[]) {
Optional<User> walkingOp = Optional.of(new User("walking", 18));
//map 如果walkingOp有值，则对其执行调用传入的函数得到返回值。
// 如果返回值不为 null(现在我们返回的是new User("new walking-20", 20))，则创建包含该返回值的Optional作为map方法返回值，否则返回空Optional。
Optional<User> userOptional1 = walkingOp.map(user -> new User("new walking-20", 20));
//walkingOP不为空，执行了函数，那么返回一个包含该值的Optional
System.out.println("包含返回值的Optional：" + userOptional1);
//现在函数返回值是null，则返回空Optional
Optional<User> userOptional2 = walkingOp.map(user -> null);
//walkingOP不为空，执行了函数，但函数返回值为空，那么返回一个空Optional
System.out.println("空Optional：" + userOptional2.toString());
Optional<User> nilOptional = Optional.ofNullable(null);
Optional<User> userOptional3 = nilOptional.map(user -> new User("原optional为空", 22));
//原optional为空，不会执行函数，返回的Optional为空
System.out.println("原optional为空:" + userOptional3.toString());
}
控制台：
包含返回值的Optional：Optional[User{name='new walking-20', age=20}]
空Optional：Optional.empty
原optional为空:Optional.empty
然后再来看一下orElse()、orElseGet()、orElseThrow()方法
public static void main(String args[]) {
Optional<User> nilOptional = Optional.ofNullable(null);
//orElse 如果存在该值，返回值， 否则返回 other。
User u = nilOptional.orElse(new User("new walking-20", 20));
System.out.println("nilOptional无值，返回传入的对象：" + u);
Optional<User> userOptional4 = Optional.of(new User("new walking-90", 90));
User user = userOptional4.orElse(new User("new walking-91", 91));
System.out.println("userOptional4有值，返回其值：" + user);
//orElseGet 如果存在该值，返回值， 否则触发 other，并返回 other 调用的结果。
User ss = nilOptional.orElseGet(() -> new User("new walking-99", 99));
System.out.println("nilOptional无值，返回函数的返回值:" + ss);
//orElseThrow 如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常
User user1 = nilOptional.orElseThrow(() -> new NullPointerException("nilOptional为空 执行函数返回的异常"));
System.out.println("nilOptional为空，返回值为空:" + user1);
}
控制台：
nilOptional无值，返回传入的对象：User{name='new walking-20', age=20}
userOptional4有值，返回其值：User{name='new walking-90', age=90}
nilOptional无值，返回函数的返回值:User{name='new walking-99', age=99}
Exception in thread "main" java.lang.NullPointerException: nilOptional为空 执行函数返回的异常
at com.walking.java8.OptionalTest.lambda$main$1(OptionalTest.java:27)
at java.util.Optional.orElseThrow(Optional.java:290)
at com.walking.java8.OptionalTest.main(OptionalTest.java:27)
6、日期时间 API
Java 8通过发布新的Date-Time API (JSR 310)来进一步加强对日期与时间的处理。
在旧版的 Java 中，日期时间 API 存在诸多问题，其中有：
-
非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
-
设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
-
时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。
Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：
-
Local(本地) − 简化了日期时间的处理，没有时区的问题。
-
Zoned(时区) − 通过制定的时区处理日期时间。
新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。
6.1 本地化日期时间 API
LocalDate/LocalTime 和 LocalDateTime 类可以在处理时区不是必须的情况。代码如下：
public static void main(String[] args) {
// 获取当前的日期时间
LocalDateTime currentTime = LocalDateTime.now();
System.out.println("当前时间: " + currentTime);
//获取当前日期
LocalDate date1 = currentTime.toLocalDate();
System.out.println("date1: " + date1);
//获取当前时间
LocalTime localTime = currentTime.toLocalTime();
System.out.println("time1: "+localTime);
int year = currentTime.getYear();
Month month = currentTime.getMonth();
int day = currentTime.getDayOfMonth();
int hour = currentTime.getHour();
int minute = currentTime.getMinute();
int seconds = currentTime.getSecond();
System.out.println("年:"+year+", 月: " + month.getValue() +", 日: " + day +",时:"+hour+",分: "+minute+", 秒: " + seconds);
//修改天，修改年
LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2018);
System.out.println("date2: " + date2);
// 2017 5 1
LocalDate date3 = LocalDate.of(2017, Month.MAY, 1);
System.out.println("date3: " + date3);
// 18 小时 20 分钟
LocalTime time2 = LocalTime.of(18, 20);
System.out.println("time2: " + time2);
// 解析字符串
LocalTime time3 = LocalTime.parse("19:50:40");
System.out.println("time3: " + time3);
}
输出：
当前时间: 2020-08-15T18:28:27.273
date1: 2020-08-15
time1: 18:28:27.273
年:2020, 月: 8, 日: 15,时:18,分: 28, 秒: 27
date2: 2018-08-10T18:28:27.273
date3: 2017-05-01
time2: 18:20
time3: 19:50:40
6.2 使用时区的日期时间API
如果我们需要考虑到时区，就可以使用时区的日期时间API：
public static void main(String[] args) {
// 获取当前的时间日期
ZonedDateTime now = ZonedDateTime.now();
System.out.println("当前时间日期: "+now.toString());
// 获取指定的时间日期
ZonedDateTime date1 = ZonedDateTime.parse("2020-08-15T18:15:30+05:30[Asia/Shanghai]");
System.out.println("指定时间日期: " + date1);
ZoneId id = ZoneId.of("Asia/Tokyo");
System.out.println("ZoneId: " + id);
ZoneId currentZone = ZoneId.systemDefault();
System.out.println("当期时区: " + currentZone);
}
控制台：
当前时间日期: 2020-08-15T18:42:47.706+08:00[Asia/Shanghai]
指定时间日期: 2020-08-15T18:15:30+08:00[Asia/Shanghai]
ZoneId: Asia/Tokyo
当期时区: Asia/Shanghai
6.3 日期格式化
public class DateTimeUtil{
public static void main(String[] args) {
//不带时间的日期
String output1 = formattedDate("2019年07月15日", "yyyy年MM月dd日", "yyyy-MM-dd");
String output2 = formattedDate("2019/07/16", "yyyy/MM/dd", "yyyy-MM-dd");
String output3 = formattedDate("2019-07-16", "yyyy-MM-dd", "yyyy/MM/dd");
System.out.println(output1);
System.out.println(output2);
System.out.println(output3);
//带时间的日期
String output4 = formattedDateTime("20190713000000", "yyyyMMddHHmmss", "yyyy-MM-dd");
String output5 = formattedDateTime("20190713000000", "yyyyMMddHHmmss", "yyyy-MM-dd HH:mm:ss");
String output6 = formattedDateTime("2019年07月14日00时00分00秒", "yyyy年MM月dd日HH时mm分ss秒",
"yyyy/MM/dd");
String output7 = formattedDateTime("2019年07月14日00时00分00秒", "yyyy年MM月dd日HH时mm分ss秒",
"yyyyMMddHHmmss");
String output8 = formattedDateTime("2019-07-15 00:00:00", "yyyy-MM-dd HH:mm:ss", "yyyyMMdd");
String output9 = formattedDateTime("2019-07-15 00:00:00", "yyyy-MM-dd HH:mm:ss",
"yyyy年MM月dd日HH时mm分ss");
System.out.println(output4);
System.out.println(output5);
System.out.println(output6);
System.out.println(output7);
System.out.println(output8);
System.out.println(output9);
}
/**
* 不带时分秒的日期字符串转化
*
* @param input 输入的日期
* @param inputFormat 输入日期的格式
* @param outputFormat 输出日期的格式
* @return 输出的日期，不带时分秒
*/
public static String formattedDate(String input, String inputFormat, String outputFormat) {
DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern(inputFormat);
LocalDate localDate = LocalDate.parse(input, inputFormatter);
DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern(outputFormat);
return localDate.format(outputFormatter);
}
/**
* 带时分秒的日期字符串转换
*
* @param input 输入的日期
* @param inputFormat 输入日期的格式
* @param outputFormat 输出日期的格式
* @return 输出指定格式的日期，可以带时分秒，也可以不带
*/
public static String formattedDateTime(String input, String inputFormat, String outputFormat) {
DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern(inputFormat);
LocalDateTime localDateTime = LocalDateTime.parse(input, inputFormatter);
DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern(outputFormat);
return localDateTime.format(outputFormatter);
}
}
6.4 Date和LocalDateTime互转
/**
* LocalDateTime -> Date
*/
public static Date toDate(LocalDateTime localDateTime) {
ZoneId zoneId = ZoneId.systemDefault();
ZonedDateTime zdt = localDateTime.atZone(zoneId);
return Date.from(zdt.toInstant());
}
/**
* Date -> LocalDateTime
*/
public static LocalDateTime toLocalDateTime(Date date) {
Instant instant = date.toInstant();
ZoneId zoneId = ZoneId.systemDefault();
return instant.atZone(zoneId).toLocalDateTime();
}
7、Base64
7.1 介绍
在Java 8中，Base64编码已经成为Java类库的标准。
Java 8 内置了 Base64 编码的编码器和解码器。
Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：
-
基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。
-
URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。
-
MIME：输出隐射到MIME友好格式。输出每行不超过76字符，并且使用' '并跟随' '作为分割。编码输出最后没有行分割。
7.2 用法
public static void main(String args[]){
try {
// 使用基本编码
String base64encodedString = Base64.getEncoder().encodeToString("walking@2020".getBytes("utf-8"));
System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);
// 解码
byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
System.out.println("Base64 编码字符串 (基本) : " + new String(base64decodedBytes, "utf-8"));
base64encodedString = Base64.getUrlEncoder().encodeToString("walking@2020".getBytes("utf-8"));
System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);
byte[] decode = Base64.getUrlDecoder().decode(base64encodedString.getBytes("utf-8"));
System.out.println("Base64 解码字符串 (URL) :"+new String(decode,"utf-8"));
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 10; ++i) {
stringBuilder.append(UUID.randomUUID().toString());
}
byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);
byte[] decode1 = Base64.getMimeDecoder().decode(mimeEncodedString.getBytes("utf-8"));
System.out.println("Base64 解码字符串 (MIME) :"+new String(decode1,"utf-8"));
}catch(UnsupportedEncodingException e){
System.out.println("Error :" + e.getMessage());
}
}
控制台输出：
Base64 编码字符串 (基本) :d2Fsa2luZ0AyMDIw
Base64 编码字符串 (基本) : walking@2020
Base64 编码字符串 (URL) :d2Fsa2luZ0AyMDIw
Base64 解码字符串 (URL) :walking@2020
Base64 编码字符串 (MIME) :N2NlZWQ2MzAtYTZiYy00NWIwLWE1OGItNzE5NzcxYTcxOGUxYzU3ODY2ZDItMTY4OC00YjczLWE5
YTEtNTFkZTViMTJlOWY4YTM2NjBkY2YtOGFjZC00M2EyLWJkNTEtMDY5Y2I3NjI2OTVjY2Q0MGI5
MzYtNjEyMC00MDBhLWIzMGEtMjU1MGQzNGQ2ODAxMDk1NzAxYTAtYjk3Yy00NTE5LTk3ZDItYzdj
MDYyM2EzZDNkNDk4MWFiYjMtZDg4Yi00NTk2LWI4MzYtMjQ5Y2RkODg5NDQ5ZWNlMDY5ZjctMzdh
Mi00ZTc3LTgxNmQtZjI2MzliMGJhMGYwM2M5OWI4NWUtMzZjOS00NjgxLWE5ZTktYjdjNTAwOTlm
YWMwZjQzOTI3YTctY2Y3ZS00ZDFhLWIxYzQtOWY1ODFkMzliY2Y1ZjYyMjM3YTUtOGI2Zi00N2Iw
LWJmNzctYjJiODJiOGM3ZDQx
Base64 解码字符串 (MIME) :7ceed630-a6bc-45b0-a58b-719771a718e1c57866d2-1688-4b73-a9a1-51de5b12e9f8a3660dcf-8acd-43a2-bd51-069cb762695ccd40b936-6120-400a-b30a-2550d34d6801095701a0-b97c-4519-97d2-c7c0623a3d3d4981abb3-d88b-4596-b836-249cdd889449ece069f7-37a2-4e77-816d-f2639b0ba0f03c99b85e-36c9-4681-a9e9-b7c50099fac0f43927a7-cf7e-4d1a-b1c4-9f581d39bcf5f62237a5-8b6f-47b0-bf77-b2b82b8c7d41
8、Nashorn JavaScript引擎
8.1 介绍
Nashorn是一个 javascript 引擎。
从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倍的性能提升。
jjs是个基于Nashorn引擎的命令行工具。它接受一些JavaScript源代码为参数，并且执行这些源代码
8.2 用法
交互式编程： 打开CMD命令窗口，输入jjs回车即可进入jjs环境，然后输入print("hello world!!")，回车
传递参数： 输入 jjs -- a b c 回车，然后输入 print("连接："+arguments.jion(", ")) 回车
执行javascript文件：我们在E盘新建test.js文件，打开文件键入： print("walking is a dashuaibi") ，打开CMD窗口进入到同目录下，输入 jjs test.js 回车
Java调用JavaScript
示例代码
public static void main(String args[]){
ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
String name = "walking";
try {
nashorn.eval("print('" + name + "')");
Integer result = (Integer) nashorn.eval("1 + 1");
System.out.println(result);
boolean re = (boolean) nashorn.eval("1 > 2");
System.out.println(re);
}catch(ScriptException e){
e.printStackTrace();
}
}
输出
walking
2
false
JavaScript 中调用 Java
以下实例演示了如何在 JavaScript 中引用 Java 类，创建JSCallJava.js文件，内容如下：
var HashMap = Java.type('java.util.HashMap');
function getHashMap(name, age) {
var result = new HashMap();
result.put("name",name);
result.put("age",age);
return result;
}
var result = getHashMap("编程大道",18);
print(result);
然后我们执行 jjs JSCallJava.js 回车
往期热文：
觉得好看，请点赞哦~
觉得好看，请 点赞、关注、转发 哦~
关注公众号 编程大道 ，第一时间获文章推送。