干货 | Java8 新特性教程

时间 2019-11-06

标签干货 java8 java 特性教程栏目 Java 繁體版

原文原文链接

本教程翻译整理自 github.com/winterbe/ja…html

更多干货文章，请关注笔者公众号: 小哈学Java (ID: xiaoha_java), 专一于分享Java领域干货文章, 不限于 BAT 面试题，算法，数据库，Spring Boot, Spring Cloud & SOA, 高并发，JVM 调优, 数据库，Docker 容器， ELK, DevOps 等相关知识，另外，关注回复「资源」，便可获取全文最热的 Java 面试&架构学习资源哟~java

你还能够去个人网站去查看此教程哦：Java8 新特性教程git

接口内容许添加默认实现的方法

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

请看下面示例代码：数据库

// 定义一个公式接口
interface Formula {
    // 计算
    double calculate(int a);

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

在上面这个接口中，咱们除了定义了一个抽象方法 calculate，还定义了一个带有默认实现的方法 sqrt。咱们在实现这个接口时，能够只须要实现 calculate 方法，默认方法 sqrt 能够直接调用便可，也就是说咱们能够没必要强制实现 sqrt 方法。编程

补充：经过 default 关键字这个新特性，能够很是方便地对以前的接口作拓展，而此接口的实现类没必要作任何改动。c#

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 行代码，非常冗余。api

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);   // 123
复制代码

Java 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);  // < 0
复制代码

Optional

首先，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);      // true
复制代码

Count 计数

count 是一个终端操做，它可以统计 stream 流中的元素总数，返回值是 long 类型。

// 先对 list 中字符串开头为 b 进行过滤，让后统计数量
long startsWithB =
    stringCollection
        .stream()
        .filter((s) -> s.startsWith("b"))
        .count();

System.out.println(startsWithB);    // 3
复制代码

Reduce

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 表示一个没有指定时区的时间类，例如，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
复制代码

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

复制代码

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
复制代码

注意：和 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 等等，我这里也仅是起到抛砖引玉的做用而已。

最后，我但愿这个教程可以对您有所帮助，也但愿您阅读愉快。

Java8 相关拓展博文

免费分享 | 面试&学习福利资源

最近在网上发现一个不错的 PDF 资源《Java 核心知识&面试.pdf》分享给你们，不光是面试，学习，你都值得拥有！！！

获取方式: 关注公众号: 小哈学Java, 后台回复资源，既可免费无套路获取资源连接，下面是目录以及部分截图：

重要的事情说两遍，关注公众号: 小哈学Java, 后台回复资源，既可免费无套路获取资源连接 ！！！