Java——Java8 新特性原理与实践

摘要

主要是的介绍一下JDK1.8的相关的新特性的知识，同时将JDK1.8新特性的代码开源在个人的github中，如果有需要参考的话请在：Senior-Architect/java语言基础 at master · 2462612540/Senior-Architect · GitHub

一、接口内允许添加默认实现的方法

Java 8 允许我们通过 default 关键字对接口中定义的抽象方法提供一个默认的实现。

package com.xjl.jdk;

/**
 * @Classname Formula
 * @Description  通过 default 关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动。
 * 在上面这个接口中，我们除了定义了一个抽象方法 calculate，还定义了一个带有默认实现的方法 sqrt。 我们在实现这个接口时，可以只需要实现 calculate 方法，
 * 默认方法 sqrt 可以直接调用即可，也就是说我们可以不必强制实现 sqrt 方法。
 * @Date 2021/9/13 20:30
 * @Created by xjl
 */
public interface Formula {
    // 计算
    double calculate(int a);

    // 求平方根
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

class Test {
    public static void main(String[] args) {
        Formula formula = new Formula() {
            @Override
            public double calculate(int a) {
                return sqrt(a * 100);
            }
        };

        double calculate = formula.calculate(100);// 100.0
        double sqrt = formula.sqrt(16);
        System.out.println(calculate+"===="+sqrt);
    }
}

在上面这个接口中，我们除了定义了一个抽象方法 calculate，还定义了一个带有默认实现的方法 sqrt。 我们在实现这个接口时，可以只需要实现 calculate 方法，默认方法 sqrt 可以直接调用即可，也就是说我们可以不必强制实现 sqrt 方法。

补充：通过 default 关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动。

二、Lambda 表达式

在学习 Lambda 表达式之前，我们先来看一段老版本的示例代码，其对一个含有字符串的集合进行排序：Collections 工具类提供了静态方法 sort 方法，入参是一个 List 集合，和一个 Comparator 比较器，以便对给定的 List 集合进行 排序。上面的示例代码创建了一个匿名内部类作为入参，这种类似的操作在我们日常的工作中随处可见。

package com.xjl.jdk.Lambda;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;

/**
 * @Classname Lambada
 * 举例子： （01，o2）->Integer.compare(o1,o2)
 * 格式：
 * lambda 操作符号 箭头符号
 * 左边是lambda的形参列表
 * 右边是lambda的重写的抽象方法的方法体
 * 

 * lmbada的本质作为接口的实例
 * @Description
 * @Date 2021/9/13 20:36
 * @Created by xjl
 */
public class Lambada {

    //语法格式一:无参，无返回值
    public void test1() {
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("我是庄晓燕");
            }
        };

        r1.run();
        System.out.println("**********新的Lambda表达式************");
        Runnable r2 = () -> System.out.println("我是庄晓燕2");
        r2.run();

    }

    //语法格式二: Ldmbda需妻一个参数，但是没有返回值。
    public void test2() {
        Consumer com = new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        com.accept("谎言和誓言的区别是什么");

        Consumer con = (String s) -> {
            System.out.println(s);
        };
        con.accept("-个是听得人当真了，一个是说的人当真了");
    }

    //语法格式三:数据类型可以省略，因为可由编译器推断得出，称为"类型推断”
    public void test3() {
        Consumer com = new Consumer() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };

        com.accept("谎言和誓言的区别是什么");
        //删除了空号中Stringd的表示
        Consumer con = (s) -> {
            System.out.println(s);
        };
        con.accept("-个是听得人当真了，一个是说的人当真了");
    }

    //语法格式Lambda若只需要一个参数时，参数的小括号可以省略
    public void test4() {

        Consumer con = s -> {
            System.out.println(s);
        };
        con.accept("-个是听得人当真了，一个是说的人当真了");
    }

    //语法格式Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
    public void test5() {

        Comparator com1 = new Comparator() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1.compareTo(o2);
            }
        };
        com1.compare(87, 90);
        System.out.println("___________________________");
        Comparator com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        com2.compare(67, 70);
    }


    //语法格式当Lambda 体只有一条语句时，return与大括号若有，都可以省略
    public void test6() {
        Comparator com2 = (o1, o2) -> o1.compareTo(o2);
        com2.compare(67, 70);
    }

    public static void main(String[] args) {
        List names = Arrays.asList("peter", "anna", "mike", "xenia");

        Collections.sort(names, new Comparator() {
            @Override
            public int compare(String a, String b) {
                return b.compareTo(a);
            }
        });

        List names2 = Arrays.asList("peter", "anna", "mike", "xenia");
        //JDK8推荐写法
        Collections.sort(names2, (String a, String b) -> {
            return b.compareTo(a);
        });
        //JDk8的lambda表达式的简单写法
        names2.sort((a, b) -> b.compareTo(a));

        for (String s : names2) {
            System.out.println(s);
        }
        System.out.println("*******************************************");
        Runnable runnable = () -> System.out.println("我是庄小焱");

        runnable.run();

        System.out.println("*******************************************");
        //方法的引用
        Comparator com = Integer::compare;
        int compare3 = com.compare(32, 21);
        System.out.println(compare3);
    }
}

三、函数式接口@Functional Interface

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口

 只包含一个抽象方法的接口，称为函数式接口。你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常(即:非运行时异常)，那么该异常需要在目标接口的抽象方法上进行声明)。我们可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一条声明，说明这个接口是一个函数式接口。在java.util.function包下定义了Java 8的丰富的函数式接口。

package com.xjl.jdk;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * java内置的4大核心函数式接口
 * 消费型接口Consumer  void accept(T t)
 * 供给型接口Supplier  T get()
 * 函数型接口Function R appLy(T t)
 * 断定型接口Predicate boolean test(T t)
 *
 * @Classname lambdaTest2
 * @Description TODO
 * @Date 2021/9/13 21:56
 * @Created by xjl
 */
public class lambdaTest2 {

    public static void main(String[] args) {
        happyTime(500, new Consumer() {
            @Override
            public void accept(Double aDouble) {
                System.out.println("好好学习");
            }
        });
        //采用的式lambda的表达式
        happyTime(400, momey -> System.out.println("好好学习+" + momey));
    }

    public static void happyTime(double money, Consumer consumer) {
        consumer.accept(money);
    }

    //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
    public static List filterString(List list, Predicate pre) {
        ArrayList filterlist = new ArrayList();
        for (String s : filterlist) {
            if (pre.test(s)) {
                filterlist.add(s);
            }
        }
        return filterlist;
    }
}

四、引用类的构造器及方法

方法引用，本质上就是Lambda麦通式，而Lambda表达式作为函数式接口的实例。所以方法引用，也是函数式接口的实例。

方法引用使用的要求:要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同!

格式:使用操作符将":"类(或对象)与方法名分隔开来。如下三种主要使用情况:

对象::实例方法名

类:静态方法名

类:实例方法名

五 构造器引用和数组引用

构造器引用：和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致.抽象方法的返回值类型即为构造器所属的类的类型

数组引用：大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。|

六、Streams API（对list的操作）

实际开发中，项目中多数数据源都来自于Mysql，Oracle等。但现在数据源可以更多了，有MongDB，Radis等，而这些NoSQL的数据就需要Java层面去处理。Stream和 Collection集合的区别:Collection是一种静态的内存数据结构，而Stream是有关计算的。前者是主要面向内存，存储在内存中,后者主要是面向CPU，通过CPU实现计算。

Stream到底是什么呢：是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。集合讲的是数据，Stream讲的是计算!注意:

• ①stream自己不会存储元素。
• ②stream不会改变源对象。相反，他们会返回一个持有结果的新Stream。stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

package com.xjl.jdk.java8.samples.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @Classname StreamTest
 * @Description TODO
 * stream关注的是对数据的运算，与CPU打交道集合关注的是数据的存储，与内存打交道
 * stream自己不会存储元素。
 * Stream不会改变源对象。相反，他们会返回一个持有结果的新Stream
 * Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
 * 

 * Stream执行流程
 * Stream的实例化
 * 一系列的中间操作（过滤、映射、...)
 * 终止操作
 * 说明:
 * 1一个中间操作链，对数据源的数据进行处理
 * 2一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用
 * @Date 2021/9/16 23:49
 * @Created by xjl
 */
class Employee {
    int id;
    String name;
    int age;
    double salary;

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
}

class EmployeeData {
    public static List getEmployees() {
        List list = new ArrayList();
        list.add(new Employee(1001, "小焱1", 34, 600.38));
        list.add(new Employee(1002, "小焱2", 35, 601.38));
        list.add(new Employee(1003, "小焱3", 36, 602.38));
        return list;
    }
}

public class StreamTest {

    //通过集合的方式
    public void test1() {
        List employees = EmployeeData.getEmployees();
        //返回一个顺序流
        Stream stream = employees.stream();
        //返回一个并行流
        Stream employeeStream = employees.parallelStream();

    }

    //通过数组的方式
    public void test2() {
        int[] array = new int[]{1, 2, 3, 4, 5, 6};
        IntStream stream = Arrays.stream(array);//返回的是一个流
    }

    //通过of的方式
    public void test3() {
        Stream integerStream = Stream.of(1, 2, 3, 4, 5);
    }

    //生成无线流
    public void test4() {
        //遍历前10日个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        //遍历前10日个偶数
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

}

• 6.1 Filter 过滤

    @Test
    public void test2() {
        //map(Function f)接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被
        List list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

        List employees = EmployeeData.getEmployees();
        Stream nameStream = employees.stream().map(Employee::getName);
        //求解员工姓名长度大于2的员工
        nameStream.filter(name -> name.length() > 2).forEach(System.out::println);
        System.out.println("---------------------------------------------------------");
        //fLatMap(Function f)--接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流合并成为一个流
        Stream streamStream = list.stream().map(StreamTest2::fromStringtoStream);
        streamStream.forEach(s -> {
            s.forEach(System.out::println);
        });
        System.out.println("---------------------------------------------------------");
        Stream characterStream = list.stream().flatMap(StreamTest2::fromStringtoStream);
        characterStream.forEach(System.out::println);
    }

• 6.2 Sorted 排序

  @Test
    public void test3() {
        //sorted()—自然排序
        //sorted( comparator com)—定制排序
        List list = Arrays.asList(12, 15, 18, 49, 57);
        list.stream().sorted().forEach(System.out::println);

        //拋异常，原因: Employee没有实现Comparable接a
        //List employees = EmployeeData.getEmployees();
        //employees.stream().sorted().forEach(System.out::println);
        System.out.println("---------------------------------------------------------");
        //实现的是定时的排序方法
        List employees = EmployeeData.getEmployees();
        employees.stream().sorted((e1, e2) -> {
            return Integer.compare(e1.getAge(), e2.getAge());
        }).forEach(System.out::println);

        //当比较大条件相同的时候 再一次选择其他的比较的条件
        employees.stream().sorted((e1, e2) -> {
            int value = Integer.compare(e1.getAge(), e2.getAge());
            if (value != 0) {
                return value;
            } else {
                return Double.compare(e1.getSalary(), e2.getSalary());
            }

        }).forEach(System.out::println);
    }

• 6.3 Map 转换 Match 匹配 Count 计数

 public void test1() {
        //allMatch(Predicate p)一检查是否匹配所有元素。
        List employees = EmployeeData.getEmployees();
        //练习:是否所有的员工的年龄都大于18
        boolean result = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(result);

        //anyMatch(Predicate p)一检查是否至少匹配一个元素。练习:是否存在员工的工资大于1
        boolean result2 = employees.stream().anyMatch(e -> e.salary > 100);
        System.out.println(result2);
        // noneMatch(Predicate p)—检查是否没有匹配的元素。
        // 练习:是否存在员工姓"雷”
        boolean result3 = employees.stream().noneMatch(e -> e.getName().startsWith("庄"));
        System.out.println(result3);

        //findFirst—-返回第一个元素
        Optional first = employees.stream().findFirst();
        System.out.println(first);

        //findAny—返回当前流中的任意元素
        Optional any = employees.stream().findAny();
        System.out.println(any);
        //count——-返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 600).count();
        System.out.println(count);

        //max( Comparator c)一返回流中最大值练习:返回最高的工资:
        Stream doubleStream = employees.stream().map(e -> e.getSalary());
        Optional max = doubleStream.max(Double::compare);
        System.out.println(max);

        //min(Comparator c)一返回流中最小值练习:返回最低工资的员工
        Optional employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);

        //forEach(Consumer c)一内部迭代

        employees.stream().forEach(System.out::println);
    }

• 6.4 Reduce

 //规约 归并处理
    @Test
    public void test1() {
        //reduce(T identity，Binaryoperator)—-可以将流中元素反复结合起来,
        List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = list.stream().reduce(0, Integer::sum);
        System.out.println(reduce);
        //reduce(BinaryOperator) 一可以将流中元素反复结合起来,
        List employees = EmployeeData.getEmployees();
        Stream doubleStream = employees.stream().map(Employee::getSalary);
        //Optional reduce1 = doubleStream.reduce(Double::sum);
        Optional reduce2 = doubleStream.reduce((e1, e2) -> e1 + e2);
        System.out.println(reduce2);
    }

    //收集
    @Test
    public void test4() {
        List employees = EmployeeData.getEmployees();
        List collect = employees.stream().filter(e -> e.getSalary() > 600).collect(Collectors.toList());
        Set collect1 = employees.stream().filter(e -> e.getSalary() > 600).collect(Collectors.toSet());
        collect1.forEach(System.out::println);
        collect.forEach(System.out::println);
    }

七、Parallel Streams 并行流

前面章节我们说过，stream 流是支持顺序和并行的。顺序流操作是单线程操作，而并行流是通过多线程来处理的，能够充分利用物理机 多核 CPU 的优势，同时处理速度更快。

首先，我们创建一个包含 1000000 UUID list 集合。

int max = 1000000;
List values = new ArrayList(max);
for (int i = 0; i < max; i++) {
    UUID uuid = UUID.randomUUID();
    values.add(uuid.toString());
}

分别通过顺序流和并行流，对这个 list 进行排序，测算耗时:

• 7.1 顺序流排序

// 纳秒
long t0 = System.nanoTime();

long count = values.stream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

// 纳秒转微秒
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("顺序流排序耗时: %d ms", millis));

// 顺序流排序耗时: 899 ms

• 7.2 并行流排序

// 纳秒
long t0 = System.nanoTime();

long count = values.parallelStream().sorted().count();
System.out.println(count);

long t1 = System.nanoTime();

// 纳秒转微秒
long millis = TimeUnit.NANOSECONDS.toMillis(t1 - t0);
System.out.println(String.format("并行流排序耗时: %d ms", millis));

// 并行流排序耗时: 472 ms

八、Map 集合

前面已经提到过 Map 是不支持 Stream 流的，因为 Map 接口并没有像 Collection 接口那样，定义了 stream() 方法。但是，我们可以对其 key, values, entry 使用 流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().

另外, JDK 8 中对 map 提供了一些其他新特性:

Map map = new HashMap();

for (int i = 0; i < 10; i++) {
    // 与老版不同的是，putIfAbent() 方法在 put 之前，
    // 会判断 key 是否已经存在，存在则直接返回 value, 否则 put, 再返回 value
    map.putIfAbsent(i, "val" + i);
}

// forEach 可以很方便地对 map 进行遍历操作
map.forEach((key, value) -> System.out.println(value));

除了上面的 putIfAbsent() 和 forEach() 外，我们还可以很方便地对某个 key 的值做相关操作：

// computeIfPresent(), 当 key 存在时，才会做相关处理
// 如下：对 key 为 3 的值，内部会先判断值是否存在，存在，则做 value + key 的拼接操作
map.computeIfPresent(3, (num, val) -> val + num);
map.get(3);             // val33

// 先判断 key 为 9 的元素是否存在，存在，则做删除操作
map.computeIfPresent(9, (num, val) -> null);
map.containsKey(9);     // false

// computeIfAbsent(), 当 key 不存在时，才会做相关处理
// 如下：先判断 key 为 23 的元素是否存在，不存在，则添加
map.computeIfAbsent(23, num -> "val" + num);
map.containsKey(23);    // true

// 先判断 key 为 3 的元素是否存在，存在，则不做任何处理
map.computeIfAbsent(3, num -> "bam");
map.get(3);             // val33

关于删除操作，JDK 8 中提供了能够新的 remove() API:如上代码，只有当给定的 key 和 value 完全匹配时，才会执行删除操作。

map.remove(3, "val3");
map.get(3);             // val33

map.remove(3, "val33");
map.get(3);             // null

关于添加方法，JDK 8 中提供了带有默认值的 getOrDefault() 方法：

/ 若 key 42 不存在，则返回 not found
map.getOrDefault(42, "not found");  // not found

对于 value 的合并操作也变得更加简单：

// merge 方法，会先判断进行合并的 key 是否存在，不存在，则会添加元素
map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9

// 若 key 的元素存在，则对 value 执行拼接操作
map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9);             // val9concat

九、新的日期 API

Java 8 中在包 java.time 下添加了新的日期 API. 它和 Joda-Time 库相似，但又不完全相同。接下来，我会通过一些示例代码介绍一下新 API 中 最关键的特性：

• 9.1 Clock

Clock 提供对当前日期和时间的访问。我们可以利用它来替代 System.currentTimeMillis() 方法。另外，通过 clock.instant() 能够获取一个 instant 实例， 此实例能够方便地转换成老版本中的 java.util.Date 对象。

Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();

Instant instant = clock.instant();
Date legacyDate = Date.from(instant);   // 老版本 java.util.Date

• 9.2 Timezones 时区

ZoneId 代表时区类。通过静态工厂方法方便地获取它，入参我们可以传入某个时区编码。另外，时区类还定义了一个偏移量，用来在当前时刻或某时间 与目标时区时间之间进行转换。

System.out.println(ZoneId.getAvailableZoneIds());
// prints all available timezone ids

ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
System.out.println(zone1.getRules());
System.out.println(zone2.getRules());

// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]

• 9.3 LocalTime

LocalTime 表示一个没有指定时区的时间类，例如，10 p.m.或者 17：30:15，下面示例代码中，将会使用上面创建的 时区对象创建两个 LocalTime。然后我们会比较两个时间，并计算它们之间的小时和分钟的不同。

LocalTime now1 = LocalTime.now(zone1);
LocalTime now2 = LocalTime.now(zone2);

System.out.println(now1.isBefore(now2));  // false

long hoursBetween = ChronoUnit.HOURS.between(now1, now2);
long minutesBetween = ChronoUnit.MINUTES.between(now1, now2);

System.out.println(hoursBetween);       // -3
System.out.println(minutesBetween);     // -239

LocalTime 提供多个静态工厂方法，目的是为了简化对时间对象实例的创建和操作，包括对时间字符串进行解析的操作等。

LocalTime late = LocalTime.of(23, 59, 59);
System.out.println(late);       // 23:59:59

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedTime(FormatStyle.SHORT)
        .withLocale(Locale.GERMAN);

LocalTime leetTime = LocalTime.parse("13:37", germanFormatter);
System.out.println(leetTime);   // 13:37

• 9.4 LocalDate

LocalDate 是一个日期对象，例如：2014-03-11。它和 LocalTime 一样是个 final 类型对象。下面的例子演示了如何通过加减日，月，年等来计算一个新的日期。LocalDate, LocalTime, 因为是 final 类型的对象，每一次操作都会返回一个新的时间对象。

LocalDate today = LocalDate.now();
// 今天加一天
LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
// 明天减两天
LocalDate yesterday = tomorrow.minusDays(2);

// 2014 年七月的第四天
LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
System.out.println(dayOfWeek);    // 星期五

也可以直接解析日期字符串，生成 LocalDate 实例。（和 LocalTime 操作一样简单）。

DateTimeFormatter germanFormatter =
    DateTimeFormatter
        .ofLocalizedDate(FormatStyle.MEDIUM)
        .withLocale(Locale.GERMAN);

LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas);   // 2014-12-24

• 9.4 LocalDateTime

LocalDateTime 是一个日期-时间对象。你也可以将其看成是 LocalDate 和 LocalTime 的结合体。操作上，也大致相同。

LocalDateTime 同样是一个 final 类型对象。

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);

DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
System.out.println(dayOfWeek);      // 星期三

Month month = sylvester.getMonth();
System.out.println(month);          // 十二月

// 获取改时间是该天中的第几分钟
long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
System.out.println(minuteOfDay);    // 1439

如果再加上的时区信息，LocalDateTime 还能够被转换成 Instance 实例。Instance 能够被转换成老版本中 java.util.Date 对象。

Instant instant = sylvester
        .atZone(ZoneId.systemDefault())
        .toInstant();

Date legacyDate = Date.from(instant);
System.out.println(legacyDate);     // Wed Dec 31 23:59:59 CET 2014

格式化 LocalDateTime 对象就和格式化 LocalDate 或者 LocalTime 一样。除了使用预定义的格式以外，也可以自定义格式化输出。

DateTimeFormatter formatter =
    DateTimeFormatter
        .ofPattern("MMM dd, yyyy - HH:mm");

LocalDateTime parsed = LocalDateTime.parse("Nov 03, 2014 - 07:13", formatter);
String string = formatter.format(parsed);
System.out.println(string);     // Nov 03, 2014 - 07:13

十、Annotations 注解

在 Java 8 中，注解是可以重复的。让我通过下面的示例代码，来看看到底是咋回事。首先，我们定义一个包装注解，里面包含了一个有着实际注解的数组：

@interface Hints {
    Hint[] value();
}

@Repeatable(Hints.class)
@interface Hint {
    String value();
}

Java 8 中，通过 @Repeatable，允许我们对同一个类使用多重注解：

第一种形态：使用注解容器（老方法）

@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {}

第二种形态：使用可重复注解（新方法）

@Hint("hint1")
@Hint("hint2")
class Person {}

使用第二种形态，Java 编译器能够在内部自动对 @Hint 进行设置。这对于需要通过反射来读取注解信息时，是非常重要的。

Hint hint = Person.class.getAnnotation(Hint.class);
System.out.println(hint);                   // null

Hints hints1 = Person.class.getAnnotation(Hints.class);
System.out.println(hints1.value().length);  // 2

Hint[] hints2 = Person.class.getAnnotationsByType(Hint.class);
System.out.println(hints2.length);          // 2

尽管我们绝对不会在 Person 类上声明 @Hints 注解，但是它的信息仍然是可以通过 getAnnotation(Hints.class) 来读取的。 并且，getAnnotationsByType 方法会更方便，因为它赋予了所有 @Hints 注解标注的方法直接的访问权限。

@Target({ElementType.TYPE_PARAMETER, ElementType.TYPE_USE})
@interface MyAnnotation {}

博文参考：

Java8 新特性教程 - 异常教程

Java语言高级-Java8/9/10/11新特性-2019-尚硅谷_哔哩哔哩_bilibili