本教程翻译整理自 https://github.com/winterbe/java8-tutorial
JAVA8新特性目录：
一、接口内允许添加默认实现的方法
二、Lambda 表达式
三、函数式接口 Functional Interface
四、便捷的引用类的构造器及方法
五、Lambda 访问外部变量及接口默认方法
5.1 访问局部变量
5.2 访问成员变量和静态变量
5.3 访问接口的默认方法
六、内置的函数式接口
6.1 Predicate 断言
6.2 Function
6.3 Supplier 生产者
6.4 Consumer 消费者
6.5 Comparator
七、Optional
八、Streams 流
8.1 Filter 过滤
8.2 Sorted 排序
8.3 Map 转换
8.4 Match 匹配
8.5 Count 计数
8.6 Reduce
九、Parallel Streams 并行流
9.1 顺序流排序
9.2 并行流排序
十、Map 集合
十一、新的日期 API
11.1 Clock
11.2 Timezones 时区
11.3 LocalTime
11.4 LocalDate
11.4 LocalDateTime
十二、Annotations 注解
小伙伴们，Java 版本都到 12 啦，我发现还有很多小伙伴对 8 的新特性不是很了解。
所以我翻译这个 Java 8 指导手册，该手册在 GitHub 上有 1W+ 的 Star, 错不了。
也希望学完本系列教程的小伙伴能够熟练掌握和应用 Java8 的各种特性，使其成为在工作中的一门利器。废话不多说，让我们一起开启 Java8 新特性之旅吧！
废话一句：如果你觉得我翻译的这篇教程有帮助到你，给我一个 Star 吧！传送门 ==> https://github.com/weiwosuoai/java8_guide
接口内允许添加默认实现的方法
Java 8 允许我们通过 default 关键字对接口中定义的抽象方法提供一个默认的实现。
请看下面示例代码：
// 定义一个公式接口
interface Formula {
// 计算
double calculate(int a);
// 求平方根
default double sqrt(int a) {
return Math.sqrt(a);
}
}在上面这个接口中，我们除了定义了一个抽象方法 calculate，还定义了一个带有默认实现的方法 sqrt。 我们在实现这个接口时，可以只需要实现 calculate 方法，默认方法 sqrt 可以直接调用即可，也就是说我们可以不必强制实现 sqrt 方法。
补充：通过
default关键字这个新特性，可以非常方便地对之前的接口做拓展，而此接口的实现类不必做任何改动。
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};
formula.calculate(100); // 100.0
formula.sqrt(16); // 4.0上面通过匿名对象实现了 Formula 接口。但是即使是这样，我们为了完成一个 sqrt(a*100) 简单计算，就写了 6 行代码，很是冗余。
Lambda 表达式
在学习 Lambda 表达式之前，我们先来看一段老版本的示例代码，其对一个含有字符串的集合进行排序：
List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});Collections 工具类提供了静态方法 sort 方法，入参是一个 List 集合，和一个 Comparator 比较器，以便对给定的 List 集合进行 排序。上面的示例代码创建了一个匿名内部类作为入参，这种类似的操作在我们日常的工作中随处可见。
Java 8 中不再推荐这种写法，而是推荐使用 Lambda 表达：
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});正如你看到的，上面这段代码变得简短很多而且易于阅读。但是我们还可以再精炼一点：
Collections.sort(names, (String a, String b) -> b.compareTo(a));
对于只包含一行方法的代码块，我们可以省略大括号，直接 return 关键代码即可。追求极致，我们还可以让它再短点：
names.sort((a, b) -> b.compareTo(a));
List 集合现在已经添加了 sort 方法。而且 Java 编译器能够根据类型推断机制判断出参数类型，这样，你连入参的类型都可以省略啦，怎么样，是不是感觉很强大呢！
函数式接口 Functional Interface
抛出一个疑问：在我们书写一段 Lambda 表达式后（比如上一章节中匿名内部类的 Lambda 表达式缩写形式），Java 编译器是如何进行类型推断的，它又是怎么知道重写的哪个方法的？
需要说明的是，不是每个接口都可以缩写成 Lambda 表达式。只有那些函数式接口（Functional Interface）才能缩写成 Lambda 表示式。
那么什么是函数式接口（Functional Interface）呢？
所谓函数式接口（Functional Interface）就是只包含一个抽象方法的声明。针对该接口类型的所有 Lambda 表达式都会与这个抽象方法匹配。
注意：你可能会有疑问，Java 8 中不是允许通过 defualt 关键字来为接口添加默认方法吗？那它算不算抽象方法呢？答案是：不算。因此，你可以毫无顾忌的添加默认方法，它并不违反函数式接口（Functional Interface）的定义。
总结一下：只要接口中仅仅包含一个抽象方法，我们就可以将其改写为 Lambda 表达式。为了保证一个接口明确的被定义为一个函数式接口（Functional Interface），我们需要为该接口添加注解： @FunctionalInterface。这样，一旦你添加了第二个抽象方法，编译器会立刻抛出错误提示。
示例代码：
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}示例代码2：
Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123注意：上面的示例代码，即使去掉
@FunctionalInterface也是好使的，它仅仅是一种约束而已。
便捷的引用类的构造器及方法
小伙伴们，还记得上一个章节这段示例代码么：
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted); // 123上面这段代码，通过 Java 8 的新特性，进一步简化上面的代码：
Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted); // 123Java 8 中允许你通过 :: 关键字来引用类的方法或构造器。上面的代码简单的示例了如何引用静态方法，当然，除了静态方法，我们还可以引用普通方法：
class Something {
String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted); // "J"接下来，我们再来看看如何通过 :: 关键字来引用类的构造器。首先，我们先来定义一个示例类，在类中声明两个构造器：
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}然后，我们再定义一个工厂接口，用来生成 Person 类：
// Person 工厂
interface PersonFactory<P extends Person> {
P create(String firstName, String lastName);
}我们可以通过 :: 关键字来引用 Person 类的构造器，来代替手动去实现这个工厂接口：
// 直接引用 Person 构造器
PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");Person::new 这段代码，能够直接引用 Person 类的构造器。然后 Java 编译器能够根据上下文选中正确的构造器去实现 PersonFactory.create 方法。
Lambda 访问外部变量及接口默认方法
在本章节中，我们将会讨论如何在 lambda 表达式中访问外部变量（包括：局部变量，成员变量，静态变量，接口的默认方法.），它与匿名内部类访问外部变量很相似。
访问局部变量
在 Lambda 表达式中，我们可以访问外部的 final 类型变量，如下面的示例代码：
// 转换器
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}final int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3
与匿名内部类不同的是，我们不必显式声明 num 变量为 final 类型，下面这段代码同样有效：
int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); stringConverter.convert(2); // 3
但是 num 变量必须为隐式的 final 类型，何为隐式的 final 呢？就是说到编译期为止， num 对象是不能被改变的，如下面这段代码，就不能被编译通过：
int num = 1; Converter<Integer, String> stringConverter = (from) -> String.valueOf(from + num); num = 3;
在 lambda 表达式内部改变 num 值同样编译不通过，需要注意, 比如下面的示例代码：
int num = 1;
Converter<Integer, String> converter = (from) -> {
String value = String.valueOf(from + num);
num = 3;
return value;
};访问成员变量和静态变量
上一章节中，了解了如何在 Lambda 表达式中访问局部变量。与局部变量相比，在 Lambda 表达式中对成员变量和静态变量拥有读写权限：
@FunctionalInterface
interface Converter<F, T> {
T convert(F from);
}class Lambda4 {
// 静态变量
static int outerStaticNum;
// 成员变量
int outerNum;
void testScopes() {
Converter<Integer, String> stringConverter1 = (from) -> {
// 对成员变量赋值
outerNum = 23;
return String.valueOf(from);
};
Converter<Integer, String> stringConverter2 = (from) -> {
// 对静态变量赋值
outerStaticNum = 72;
return String.valueOf(from);
};
}
}访问接口的默认方法
还记得第一章节中定义的那个 Formula (公式) 接口吗？
@FunctionalInterface
interface Formula {
// 计算
double calculate(int a);
// 求平方根
default double sqrt(int a) {
return Math.sqrt(a);
}
}当时，我们在接口中定义了一个带有默认实现的 sqrt 求平方根方法，在匿名内部类中我们可以很方便的访问此方法：
Formula formula = new Formula() {
@Override
public double calculate(int a) {
return sqrt(a * 100);
}
};但是在 lambda 表达式中可不行：
Formula formula = (a) -> sqrt(a * 100);
带有默认实现的接口方法，是不能在 lambda 表达式中访问的，上面这段代码将无法被编译通过。
内置的函数式接口
JDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 Comparator 和 Runnable，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。
值得一提的是，除了 Comparator 和 Runnable 外，还有一些新的函数式接口，它们很多都借鉴于知名的 Google Guava 库。
对于它们，即使你已经非常熟悉了，还是最好了解一下的：
Predicate 断言
Predicate 是一个可以指定入参类型，并返回 boolean 值的函数式接口。它内部提供了一些带有默认实现的方法，可以 被用来组合一个复杂的逻辑判断（ and, or, negate）：
Predicate<String> predicate = (s) -> s.length() > 0;
predicate.test("foo"); // true
predicate.negate().test("foo"); // false
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();Function
Function 函数式接口的作用是，我们可以为其提供一个原料，他给生产一个最终的产品。通过它提供的默认方法，组合,链行处理( compose, andThen)：
Function<String, Integer> toInteger = Integer::valueOf;
Function<String, String> backToString = toInteger.andThen(String::valueOf);
backToString.apply("123"); // "123"Supplier 生产者
Supplier 与 Function 不同，它不接受入参，直接为我们生产一个指定的结果，有点像生产者模式：
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}Supplier<Person> personSupplier = Person::new; personSupplier.get(); // new Person
Consumer 消费者
对于 Consumer，我们需要提供入参，用来被消费，如下面这段示例代码：
class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
greeter.accept(new Person("Luke", "Skywalker"));Comparator
Comparator 在 Java 8 之前是使用比较普遍的。Java 8 中除了将其升级成了函数式接口，还为它拓展了一些默认方法：
Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator.compare(p1, p2); // > 0
comparator.reversed().compare(p1, p2); // < 0Optional
首先， Optional 它不是一个函数式接口，设计它的目的是为了防止空指针异常（ NullPointerException），要知道在 Java 编程中， 空指针异常可是臭名昭著的。
让我们来快速了解一下 Optional 要如何使用！你可以将 Optional 看做是包装对象（可能是 null, 也有可能非 null）的容器。当你定义了 一个方法，这个方法返回的对象可能是空，也有可能非空的时候，你就可以考虑用 Optional 来包装它，这也是在 Java 8 被推荐使用的做法。
Optional<String> optional = Optional.of("bam");
optional.isPresent(); // true
optional.get(); // "bam"
optional.orElse("fallback"); // "bam"
optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"Stream 流
这一章节，我们开始步入学习 Stream 流。
什么是 Stream 流？
简单来说，我们可以使用 java.util.Stream 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 中间操作 亦或是 终端操作。 终端操作会返回一个结果，而中间操作会返回一个 Stream 流。
需要注意的是，你只能对实现了 java.util.Collection 接口的类做流的操作。
Map不支持Stream流。
Stream 流支持同步执行，也支持并发执行。
让我们开始步入学习的旅程吧！Go !
Filter 过滤
首先，我们创建一个 List 集合：
List<String> stringCollection = new ArrayList<>();
stringCollection.add("ddd2");
stringCollection.add("aaa2");
stringCollection.add("bbb1");
stringCollection.add("aaa1");
stringCollection.add("bbb3");
stringCollection.add("ccc");
stringCollection.add("bbb2");
stringCollection.add("ddd1");Filter 的入参是一个 Predicate, 上面已经说到， Predicate 是一个断言的中间操作，它能够帮我们筛选出我们需要的集合元素。它的返参同样 是一个 Stream 流，我们可以通过 foreach 终端操作，来打印被筛选的元素：
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa2", "aaa1"注意：
foreach是一个终端操作，它的返参是void, 我们无法对其再次进行流操作。
Sorted 排序
Sorted 同样是一个中间操作，它的返参是一个 Stream 流。另外，我们可以传入一个 Comparator 用来自定义排序，如果不传，则使用默认的排序规则。
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
// "aaa1", "aaa2"需要注意， sorted 不会对 stringCollection 做出任何改变， stringCollection 还是原有的那些个元素，且顺序不变：
System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
Map 转换
中间操作 Map 能够帮助我们将 List 中的每一个元素做功能处理。例如下面的示例，通过 map 我们将每一个 string 转成大写：
stringCollection .stream() .map(String::toUpperCase) .sorted((a, b) -> b.compareTo(a)) .forEach(System.out::println); // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"
另外，我们还可以做对象之间的转换，业务中比较常用的是将 DO（数据库对象） 转换成BO（业务对象） 。
Match 匹配
顾名思义， match 用来做匹配操作，它的返回值是一个 boolean 类型。通过 match, 我们可以方便的验证一个 list 中是否存在某个类型的元素。
// 验证 list 中 string 是否有以 a 开头的, 匹配到第一个，即返回 true
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
// 验证 list 中 string 是否都是以 a 开头的
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
// 验证 list 中 string 是否都不是以 z 开头的,
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // trueCount 计数
count 是一个终端操作，它能够统计 stream 流中的元素总数，返回值是 long 类型。
// 先对 list 中字符串开头为 b 进行过滤，让后统计数量
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3Reduce
Reduce 中文翻译为：减少、缩小。通过入参的 Function，我们能够将 list 归约成一个值。它的返回类型是 Optional 类型。
Optional<String> reduced = stringCollection .stream() .sorted() .reduce((s1, s2) -> s1 + "#" + s2); reduced.ifPresent(System.out::println); // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"
Parallel-Streams 并行流
前面章节我们说过， stream 流是支持顺序和并行的。顺序流操作是单线程操作，而并行流是通过多线程来处理的，能够充分利用物理机 多核 CPU 的优势，同时处理速度更快。
首先，我们创建一个包含 1000000 UUID list 集合。
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}分别通过顺序流和并行流，对这个 list 进行排序，测算耗时:
顺序流排序
// 纳秒
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并行流排序
// 纳秒
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正如你所见，同样的逻辑处理，通过并行流，我们的性能提升了近 50%。完成这一切，我们需要做的仅仅是将 stream 改成了 parallelStream。
Map 集合
前面已经提到过 Map 是不支持 Stream 流的，因为 Map 接口并没有像 Collection 接口那样，定义了 stream() 方法。但是，我们可以对其 key, values, entry 使用 流操作，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().
另外, JDK 8 中对 map 提供了一些其他新特性:
Map<Integer, String> 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:
map.remove(3, "val3"); map.get(3); // val33 map.remove(3, "val33"); map.get(3); // null
如上代码，只有当给定的 key 和 value 完全匹配时，才会执行删除操作。
关于添加方法，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 中 最关键的特性：
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
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]LocalTime
LocalTime 表示一个没有指定时区的时间类，例如， 10p.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:37LocalDate
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-24LocalDateTime
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注意：和
java.text.NumberFormat不同，新的DateTimeFormatter类是final类型的，同时也是线程安全的。更多细节请查看这里
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 {}结语
Java 8 新特性的编程指南到此就告一段落了。当然，还有很多内容需要进一步研究和说明。这就需要靠读者您来对 JDK 8 进行探究了， 例如： Arrays.parallelSort, StampedLock 和 CompletableFuture 等等, 我这里只是举几个例子而已。
最后，我希望这个博文能够对您有所帮助，也希望您阅读愉快，谢谢啦。