有点干货 | Jdk1.8新特性实战篇(41个案例)
做者：小傅哥
博客：https://bugstack.cn - 原创系列优质专题文章html
沉淀、分享、成长，让本身和他人都能有所收获！
前言
一直想把jdk1.8的新特性整理下，刚好看到老外的git(文后有连接)，在这个结构上继续完善了说明和功能，作了41个单元测试案例，方便新人学习。如下内容很干，对于一个萌新小白来讲，学习jdk1.8的新特性，基本看一遍就知道个7788了，在熟读两遍最后跟着写一遍，那么在实际项目中就能够运用了。不过！新特性，虽然很好。但若是想用，那么本身必定要看看相对应的源码并多练习，不然真的容易给本身搞晕，又很难阅读。java
零、回顾一个抽象类
在jdk1.8以前，由于接口里只能作方法定义不能有方法的实现，所以咱们一般会在抽象类里面实现默认的方法｛通常这个默认的方法是抽象后公用的方法，不须要每个继承者都去实现，只需调用便可｝。就像下面这样；git
在定义的时候；
public abstract class AFormula {
abstract double calculate(int a);
// 平方
double sqrt(int a) {
return Math.sqrt(a);
}
}
在使用的时候；
@Test
public void test_00() {
AFormula aFormula = new AFormula() {
@Override
double calculate(int a) {
return a * a;
}
};
System.out.println(aFormula.calculate(2)); //求平方：4
System.out.println(aFormula.sqrt(2)); //求开方：1.4142135623730951
}
1、在接口中提供默认的方法实现（有点像抽象类）
在jdk1.8里面，不只能够定义接口，还能够在接口中提供默认的实现。这一个小小的改变却让整个抽象设计都随着改变了！github
在定义的时候；{default 关键字必须}
public interface IFormula {
double calculate(int a);
// 平方
default double sqrt(int a) {
return Math.sqrt(a);
}
}
在使用的时候(一)；
@Test
public void test_01() {
IFormula formula = new IFormula() {
@Override
public double calculate(int a) {
return a * a;
}
};
System.out.println(formula.calculate(2));
System.out.println(formula.sqrt(2));
}
在使用的时候(二)；若是只是一里面方式这么使用，那么就没多大意思了。我一直说过；好的代码都很骚！
- a; a是一个入参名称，能够其余任何名字
- ->a*a； 箭头指向是具体的实现
- 可是，这样其实不太适合加日志了
@Test
public void test_02() {
// 入参a 和 实现
IFormula formula = a -> a * a;
System.out.println(formula.calculate(2));
System.out.println(formula.sqrt(2));
}
2、Lambda 表达式
由于有接口中能够增长默认的方法实现，那么Java确定是由于要简化开发才出现的这么个设计。因此你会从各个咱们之前的List、Set等等全部接口中看到默认的方法实现。express
从一段熟悉的排序列子入手编程
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 集合进行排序。上面的示例代码建立了一个匿名内部类做为入参，这种相似的操做在咱们平常的工做中随处可见。c#
Java 8 中再也不推荐这种写法，而是推荐使用 Lambda 表达：segmentfault
Collections.sort(names, (String a, String b) -> {
return b.compareTo(a);
});
上面的这段一样功能的代码块，简短干净了许多。就像婆媳同样可能刚开始看不习惯，可是接触接触就喜欢了。由于，它还能够更加简短优秀；设计模式
Collections.sort(names, (String a, String b) -> b.compareTo(a));
为了追求极致，咱们还可让它再短点：｛固然过你的实现不是一行代码，那么不能这么干｝api
names.sort((a, b) -> b.compareTo(a));
java.util.List 集合如今已经添加了 sort 方法。并且 Java 编译器可以根据类型推断机制判断出参数类型，这样，你连入参的类型均可以省略啦，怎么样，是否是感受很骚气呢！
java.util.List.sort
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
好了！你觉得这就结束了吗，不！它还能够更短！(得益于Comparator接口中还提供了stack默认方法，也就是说接口中不是只可有default默认实现，还能够有静态方法)
names.sort(Comparator.reverseOrder());
2、函数式接口 Functional Interfaces
How does lambda expressions fit into Java's type system? Each lambda corresponds to a given type, specified by an interface. A so called functional interface must contain exactly one abstract method declaration. Each lambda expression of that type will be matched to this abstract method. Since default methods are not abstract you're free to add default methods to your functional interface.
经过上面的例子咱们能够看到经过Lambda能够开发出一样功能的逻辑可是代码却很简单，那么Jvm是如何进行类型推断，而且找到对应的方法呢？
经过官文介绍以及咱们使用发现，并非每一个接口均可以缩写成Lambda表达式的开发方式。实际上是只有那些函数式接口(Functional Interface)才能缩写成 Lambda 表示式。
所谓函数式接口(Functional Interface)就是只包含一个抽象方法的声明。针对该接口类型的全部 Lambda 表达式都会与这个抽象方法匹配。{另外，只是在接口上添加default并不算抽象方法}
总结：为了保证一个接口明确的被定义为一个函数式接口(Functional Interface)，咱们须要为该接口添加注解：@FunctionalInterface。这样，一旦你添加了第二个抽象方法，编译器会马上抛出错误提示。｛不填写，可是只写一个default也能够｝
定义含有注解@FunctionalInterface的接口
@FunctionalInterface
public interface IConverter<F, T> {
T convert(F from);
}
- 先来一段传统方式 & 简单易懂哈，由于看习惯了
IConverter<String, Integer> converter01 = new IConverter<String, Integer>() {
@Override
public Integer convert(String from) {
return Integer.valueOf(from);
}
- 稍微简化下，化个妆 & (form)，只有一个参数括号能够不要
IConverter<String, Integer> converter02 = (from) -> {
return Integer.valueOf(from);
};
- 继续简化，由于他的实现只有一行代码，能够更加简短
IConverter<String, Integer> converter03 = from -> Integer.valueOf(from);
- 还能短点，其实这个另类属于下一段的内容了，先放这有个印象
IConverter<Integer, String> converter04 = String::valueOf;
3、方法和构造函数的便捷引用
在上面咱们先加了印象片断 XX::xx，它也是Java8的新特性便捷式引用，这四个点可能你在其余语言里也见过。
IConverter<Integer, String> converter04 = String::valueOf; String converted04 = converter04.convert(11); System.out.println(converted04);
这四个点::的关键字，不仅是能够引用方法和构造函数，还能够引用普通方法。
public class Something{
public String startsWith(String s) {
return String.valueOf(s.charAt(0));
}
}
IConverter<String, String> converter01 = s -> String.valueOf(s.charAt(0)); //[参照物]直接把逻辑放到这调用
IConverter<String, String> converter02 = something::startsWith; //引用的方法体里面逻辑能够更多，不然只是一句代码并不能适合全部的状况
System.out.println(converter01.convert("Java"));
System.out.println(converter02.convert("Java"));
接下来咱们在使用这四个点，来看下如何引用类的构造器。首先咱们建立一个这样的类；
public class Person {
String firstName;
String lastName;
Person() {}
Person(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
}
而后我还须要顶一个工厂类，用于生成Person对象；
@FunctionalInterface
public interface IPersonFactory<P extends Person> {
P create(String firstName, String lastName);
}
如今就到了用四饼::的时候了；
IPersonFactory<Person> personFactory = Person::new; //[参照物]：(firstName, lastName) -> new Person(firstName, lastName);
Person person = personFactory.create("Peter", "Parker");
提醒；工厂函数中依然只能有一个函数，不然会报错
四饼::，可让咱们直接引用到Person类的构造函数，而后 Java 编译器可以根据类的签名选中正确的构造器去实现 PersonFactory.create 方法。
4、Lambda做用范围
Accessing outer scope variables from lambda expressions is very similar to anonymous objects. You can access final variables from the local outer scope as well as instance fields and static variables.
Lambda表达式访问外部的变量(局部变量，成员变量，静态变量，接口的默认方法),它与匿名内部类访问外部变量很是类似。
1. 访问局部变量
咱们能够从lambda表达式的外部范围读取最终局部变量num；
int num = 1; IConverter<Integer, String> stringConverter = from -> String.valueOf(from + num); String convert = stringConverter.convert(2); System.out.println(convert); // 3
可是这个num是不可变值，这样改变值会报错；
int num = 1;
IConverter<Integer, String> stringConverter =
(from) -> String.valueOf(from + num);
num = 3;
Variable used in lambda expression should be final or effectively final
另外在lambda表达式内部修改也是不容许的；
int num = 1;
IConverter<Integer, String> converter = (from) -> {
String value = String.valueOf(from + num);
num = 3;
return value;
};
Variable used in lambda expression should be final or effectively final
2. 访问成员变量和静态变量
在 Lambda 表达式中访问局部变量。与局部变量相比，在 Lambda 表达式中对成员变量和静态变量拥有读写权限：
public class Lambda4 {
// 静态变量
static int outerStaticNum;
// 成员变量
int outerNum;
void testScopes() {
IConverter<Integer, String> stringConverter1 = (from) -> {
// 对成员变量赋值
outerNum = 23;
return String.valueOf(from);
};
IConverter<Integer, String> stringConverter2 = (from) -> {
// 对静态变量赋值
outerStaticNum = 72;
return String.valueOf(from);
};
}
}
3. 访问默认接口方法
还记得第一节的IFormula示例吗？
public interface IFormula {
double calculate(int a);
// 平方
default double sqrt(int a) {
return Math.sqrt(a);
}
}
当时，咱们在接口中定义了一个带有默认实现的 sqrt 求平方根方法，在匿名内部类中咱们能够很方便的访问此方法：
IFormula formula = new IFormula() {
@Override
public double calculate(int a) {
return a * a;
}
};
可是不能经过lambda表达式访问默认方法，这样的代码无法经过编译；
IFormula formula = (a) -> sqrt(a * a);
带有默认实现的接口方法，是不能在 lambda 表达式中访问的，上面这段代码将没法被编译经过。
5、内置的函数式接口
JDK 1.8 API 包含了不少内置的函数式接口。其中就包括咱们在老版本中常常见到的 Comparator 和 Runnable，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。
例如咱们旧版本的Jdk中经常使用的 Comparator 和 Runnable 外，还有一些新的函数式接口，能够经过函数注解实现Lamdba支持，它们不少都借鉴于知名的 Google Guava 库。
即便你已经熟悉这个类库，也应该密切关注那些接口是如何经过一些有用的方法扩展来扩展的：
1. Predicate 断言
Predicate 是一个能够指定入参类型，并返回 boolean 值的函数式接口。它内部提供了一些带有默认实现的方法，能够 被用来组合一个复杂的逻辑判断（and, or, negate）：
@Test
public void test11() {
Predicate<String> predicate = (s) -> s.length() > 0;
boolean foo0 = predicate.test("foo"); // true
boolean foo1 = predicate.negate().test("foo"); // negate否认至关于!true
Predicate<Boolean> nonNull = Objects::nonNull;
Predicate<Boolean> isNull = Objects::isNull;
Predicate<String> isEmpty = String::isEmpty;
Predicate<String> isNotEmpty = isEmpty.negate();
}
2. Functions
Function 函数式接口的做用是，咱们能够为其提供一个原料，他给生产一个最终的产品。经过它提供的默认方法，组合,链行处理(compose, andThen)：
@Test
public void test12() {
Function<String, Integer> toInteger = Integer::valueOf; //转Integer
Function<String, String> backToString = toInteger.andThen(String::valueOf); //转String
Function<String, String> afterToStartsWith = backToString.andThen(new Something()::startsWith); //截取第一位
String apply = afterToStartsWith.apply("123");// "123"
System.out.println(apply);
}
3. Suppliers
Supplier 与 Function 不一样，它不接受入参，直接为咱们生产一个指定的结果，有点像生产者模式：
@Test
public void test13() {
Supplier<Person> personSupplier0 = Person::new;
personSupplier0.get(); // new Person
Supplier<String> personSupplier1 = Something::test01; //这个test方法是静态的，且无入参
personSupplier1.get(); // hi
Supplier<String> personSupplier2 = new Something()::test02;
}
4. Consumers
对于 Consumer，咱们须要提供入参，用来被消费，以下面这段示例代码：
@Test
public void test14() {
// 参照物，方便知道下面的Lamdba表达式写法
Consumer<Person> greeter01 = new Consumer<Person>() {
@Override
public void accept(Person p) {
System.out.println("Hello, " + p.firstName);
}
};
Consumer<Person> greeter02 = (p) -> System.out.println("Hello, " + p.firstName);
greeter02.accept(new Person("Luke", "Skywalker")); //Hello, Luke
Consumer<Person> greeter03 = new MyConsumer<Person>()::accept; // 也能够经过定义类和方法的方式去调用，这样才是实际开发的姿式
greeter03.accept(new Person("Luke", "Skywalker")); //Hello, Luke
}
5. Comparators
Comparator 在 Java 8 以前是使用比较广泛的。Java 8 中除了将其升级成了函数式接口，还为它拓展了一些默认方法：
@Test
public void test15(){
Comparator<Person> comparator01 = (p1, p2) -> p1.firstName.compareTo(p2.firstName);
Comparator<Person> comparator02 = Comparator.comparing(p -> p.firstName); //等同于上面的方式
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice", "Wonderland");
comparator01.compare(p1, p2); // > 0
comparator02.reversed().compare(p1, p2); // < 0
}
6、Optionals
首先，Optional 它不是一个函数式接口，设计它的目的是为了防止空指针异常（NullPointerException），要知道在 Java 编程中，空指针异常但是臭名昭著的。
让咱们来快速了解一下 Optional 要如何使用！你能够将 Optional 看作是包装对象（多是 null, 也有可能非 null）的容器。当你定义了
一个方法，这个方法返回的对象多是空，也有可能非空的时候，你就能够考虑用 Optional 来包装它，这也是在 Java 8 被推荐使用的作法。
@Test
public void test16(){
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"
Optional<Person> optionalPerson = Optional.of(new Person());
optionalPerson.ifPresent(s -> System.out.println(s.firstName));
}
7、Stream 流
什么是 Stream 流？
简单来讲，咱们可使用 java.util.Stream 对一个包含一个或多个元素的集合作各类操做。这些操做多是 中间操做 亦或是 终端操做。
终端操做会返回一个结果，而中间操做会返回一个 Stream 流。
须要注意的是，你只能对实现了 java.util.Collection 接口的类作流的操做。
Stream 流支持同步执行，也支持并发执行。
注意：Map不支持Stream流，可是他的key和value是支持的！
让咱们先看看Stream流是如何工做的。首先，咱们以字符串列表的形式建立一个示例；
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");
1. Filter 过滤
Filter 的入参是一个 Predicate, 上面已经说到，Predicate 是一个断言的中间操做，它可以帮咱们筛选出咱们须要的集合元素。它的返参一样 是一个 Stream 流，咱们能够经过 foreach 终端操做，来打印被筛选的元素：
@Test
public void test17(){
stringCollection
.stream()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
}
2. Sorted 排序
Sorted 一样是一个中间操做，它的返参是一个 Stream 流。另外，咱们能够传入一个 Comparator 用来自定义排序，若是不传，则使用默认的排序规则。
@Test
public void test18() {
stringCollection
.stream()
.sorted()
.filter((s) -> s.startsWith("a"))
.forEach(System.out::println);
}
注意；这个sorted 只是作了一个排序的视图进行输出，实际没有将List内的数据进行排序
System.out.println(stringCollection); // ddd2, aaa2, bbb1, aaa1, bbb3, ccc, bbb2, ddd1
3. Map 转换
中间操做映射经过给定的函数将每一个元素转换为另外一个对象。例以下面的示例，经过 map 咱们将每个 string 转成大写：
@Test
public void test19(){
stringCollection
.stream()
.map(String::toUpperCase)
.sorted(Comparator.reverseOrder()) //等同于(a, b) -> b.compareTo(a)
.forEach(System.out::println);
}
这个能够用作DTO数据对象转换，领域驱动设计开发中将DTO转为DO向后台传输。
4. Match 匹配
顾名思义，match 用来作匹配操做，它的返回值是一个 boolean 类型。经过 match, 咱们能够方便的验证一个 list 中是否存在某个类型的元素。
@Test
public void test20(){
// anyMatch：验证 list 中 string 是否有以 a 开头的, 匹配到第一个，即返回 true
boolean anyStartsWithA =
stringCollection
.stream()
.anyMatch((s) -> s.startsWith("a"));
System.out.println(anyStartsWithA); // true
// allMatch：验证 list 中 string 是否都是以 a 开头的
boolean allStartsWithA =
stringCollection
.stream()
.allMatch((s) -> s.startsWith("a"));
System.out.println(allStartsWithA); // false
// noneMatch：验证 list 中 string 是否都不是以 z 开头的
boolean noneStartsWithZ =
stringCollection
.stream()
.noneMatch((s) -> s.startsWith("z"));
System.out.println(noneStartsWithZ); // true
}
5. Count 计数
count 是一个终端操做，它可以统计 stream 流中的元素总数，返回值是 long 类型。
@Test
public void test21() {
// count：先对 list 中字符串开头为 b 进行过滤，让后统计数量
long startsWithB =
stringCollection
.stream()
.filter((s) -> s.startsWith("b"))
.count();
System.out.println(startsWithB); // 3
}
6. Reduce
Reduce 中文翻译为：减小、缩小。经过入参的 Function，咱们可以将 list 归约成一个值。它的返回类型是 Optional 类型。
@Test
public void test22() {
Optional<String> reduced =
stringCollection
.stream()
.sorted()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println);
// aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2
}
8、Parallel-Streams 并行流
如上所述，流能够是顺序的，也能够是并行的。顺序流上的操做在单个线程上执行，而并行流上的操做在多个线程上并发执行。
下面的示例演示了使用并行流来提升性能是多么的容易。亲测提高了1倍性能！
首先，咱们建立一个较大的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());
}
1. Sequential Sort 顺序流排序
@Test
public void test23() {
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
// 纳秒
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));
//顺序流排序耗时: 712 ms
}
2. Parallel Sort 并行流排序
@Test
public void test24(){
int max = 1000000;
List<String> values = new ArrayList<>(max);
for (int i = 0; i < max; i++) {
UUID uuid = UUID.randomUUID();
values.add(uuid.toString());
}
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("parallel sort took: %d ms", millis));
//parallel sort took: 385 ms
}
如您所见，这两个代码片断几乎相同，但并行排序大约快50%。您只需将stream（）更改成parallelStream（）。
9、Map 集合
如前所讲，Map是不支持 Stream 流的，由于 Map 接口并无像 Collection 接口那样，定义了 stream() 方法。可是，咱们能够对其 key, values, entry 使用 流操做，如 map.keySet().stream(), map.values().stream() 和 map.entrySet().stream().
另外, JDK 8 中对 map 提供了一些其余新特性:
@Test
public void test25() {
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
// 与老版不一样的是，putIfAbent() 方法在 put 以前， 不用在写if null continue了
// 会判断 key 是否已经存在，存在则直接返回 value, 不然 put, 再返回 value
map.putIfAbsent(i, "val" + i);
}
// forEach 能够很方便地对 map 进行遍历操做
map.forEach((key, value) -> System.out.println(value));
}
以后咱们作一个Map对象的转换输出；（定义两个类BeanA、BeanB）
@Test
public void test26() {
Map<Integer, BeanA> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
// 与老版不一样的是，putIfAbent() 方法在 put 以前， 不用在写if null continue了
// 会判断 key 是否已经存在，存在则直接返回 value, 不然 put, 再返回 value
map.putIfAbsent(i, new BeanA(i, "明明" + i, i + 20, "89021839021830912809" + i));
}
Stream<BeanB> beanBStream00 = map.values().stream().map(new Function<BeanA, BeanB>() {
@Override
public BeanB apply(BeanA beanA) {
return new BeanB(beanA.getName(), beanA.getAge());
}
});
Stream<BeanB> beanBStream01 = map.values().stream().map(beanA -> new BeanB(beanA.getName(), beanA.getAge()));
beanBStream01.forEach(System.out::println);
}
除了上面的 putIfAbsent() 和 forEach() 外，咱们还能够很方便地对某个 key 的值作相关操做：
@Test
public void test27() {
// 以下：对 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:
@Test
public void test28() {
map.remove(3, "val3");
map.get(3); // val33
map.remove(3, "val33");
map.get(3); // null
}
如上代码，只有当给定的 key 和 value 彻底匹配时，才会执行删除操做。
关于添加方法，JDK 8 中提供了带有默认值的 getOrDefault() 方法：
@Test
public void test29() {
// 若 key 42 不存在，则返回 not found
map.getOrDefault(42, "not found"); // not found
}
对于 value 的合并操做也变得更加简单：
@Test
public void test30() {
// 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
}
10、日期 Date API
Java 8 中在包 java.time 下添加了新的日期 API. 它和 Joda-Time 库类似，但又不彻底相同。接下来，我会经过一些示例代码介绍一下新 API 中 最关键的特性：
1. Clock
Clock 提供对当前日期和时间的访问。咱们能够利用它来替代 System.currentTimeMillis() 方法。另外，经过 clock.instant() 可以获取一个 instant 实例，
此实例可以方便地转换成老版本中的 java.util.Date 对象。
@Test
public void test31(){
Clock clock = Clock.systemDefaultZone();
long millis = clock.millis();
Instant instant = clock.instant();
Date legacyDate = Date.from(instant); // 老版本 java.util.Date
}
2. Timezones 时区
ZoneId 表明时区类。经过静态工厂方法方便地获取它，入参咱们能够传入某个时区编码。另外，时区类还定义了一个偏移量，用来在当前时刻或某时间 与目标时区时间之间进行转换。
@Test
public void test32() {
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());
//[Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/Gada/Atlantic, Atlantic/St_Helena, Australia/Tasmania, Libya, Europe/Guernsey, America/Grand_Turk, US/Pacific-New, Asia/Samarkand, America/Argentina/Cordoba, Asia/Phnom_Penh, Africa/Kigali, Asia/Almaty, US/Alaska, Asi...
// ZoneRules[currentStandardOffset=+01:00]
// ZoneRules[currentStandardOffset=-03:00]
}
3. LocalTime
LocalTime 表示一个没有指定时区的时间类，例如，10 p.m.或者 17：30:15，下面示例代码中，将会使用上面建立的 时区对象建立两个 LocalTime。而后咱们会比较两个时间，并计算它们之间的小时和分钟的不一样。
@Test
public void test33(){
ZoneId zone1 = ZoneId.of("Europe/Berlin");
ZoneId zone2 = ZoneId.of("Brazil/East");
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 提供多个静态工厂方法，目的是为了简化对时间对象实例的建立和操做，包括对时间字符串进行解析的操做等。
@Test
public void test34(){
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
}
4. LocalDate
LocalDate 是一个日期对象，例如：2014-03-11。它和 LocalTime 同样是个 final 类型对象。下面的例子演示了如何经过加减日，月，年等来计算一个新的日期。
@Test
public void test35(){
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 操做同样简单）
@Test
public void test36(){
DateTimeFormatter germanFormatter =
DateTimeFormatter
.ofLocalizedDate(FormatStyle.MEDIUM)
.withLocale(Locale.GERMAN);
LocalDate xmas = LocalDate.parse("24.12.2014", germanFormatter);
System.out.println(xmas); // 2014-12-24
}
5. LocalDateTime
LocalDateTime 是一个日期-时间对象。你也能够将其当作是 LocalDate 和 LocalTime 的结合体。操做上，也大体相同。
@Test
public void test37(){
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 对象。
@Test
public void test38(){
LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
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 同样。除了使用预约义的格式之外，也能够自定义格式化输出。
@Test
public void test39(){
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
}
Unlike java.text.NumberFormat the new DateTimeFormatter is immutable and thread-safe.
For details on the pattern syntax read here.
11、Annotations 注解
Java8中的注释是可重复的。让咱们直接深刻到一个例子中来解决这个问题。{在SpringBoot的启动类中就能够看到这中类型的注解}
首先，咱们定义一个包装器注释，它包含一个实际注释数组：
@Repeatable(Hints.class)
public @interface Hint {
String value();
}
public @interface Hints {
Hint[] value();
}
Java 8经过声明注释@Repeatable，使咱们可以使用同一类型的多个注释。
第一种形态：使用注解容器（老方法）
@Test
public void test40() {
@Hints({@Hint("hint1"), @Hint("hint2")})
class Person {
}
}
第二种形态：使用可重复注解（新方法）
@Test
public void test41() {
@Hint("hint1")
@Hint("hint2")
class Person {
}
}
java编译器使用变量2隐式地在引擎盖下设置@Hints注释。这对于经过反射读取注释信息很重要。
@Test
public void test41() {
@Hint("hint1")
@Hint("hint2")
class Person {
}
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 {}
综上总结
- jdk8的新特性包括了；Lambda、函数式接口、四饼调用::、内置函数(断言、Function、生产者、消费者)、Stream流、Map集合特性、日期、注解等
- 合理的组合运行新的特性能够减小不少的编码量，同时让代码更加整洁
- 在一些新的框架中SpringBoot里若是翻看源码能够看到不少的新特性使用
- 案例来源；https://github.com/winterbe/j... ｛英文｝
- 源码贡献；https://github.com/fuzhengwei/itstack-demo-jdk8
推荐阅读
- 1. 有点干货 | Jdk1.8新特性实战篇(41个案例)
- 2. Java 13 新特性及实战案例
- 3. JDK1.8十个新特性
- 4. JDK1.8新特性(一)：JDK1.8究竟有哪些新特性呢
- 5. JDK1.8新特性
- 6. jdk1.8 新特性
- 7. jdk1.8新特性
- 8. 一个影响力大、实战、干货的SEO案例
- 9. JDK1.8 新特性（全）
- 10. JDK1.8的新特性
- 更多相关文章...
- • PHP 7 新特性 - PHP教程
- • MySQL 5.7的新特性（新功能） - MySQL教程
- • JDK13 GA发布：5大特性解读
- • 再有人问你分布式事务，把这篇扔给他
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 有点干货 | Jdk1.8新特性实战篇(41个案例)
- 2. Java 13 新特性及实战案例
- 3. JDK1.8十个新特性
- 4. JDK1.8新特性(一)：JDK1.8究竟有哪些新特性呢
- 5. JDK1.8新特性
- 6. jdk1.8 新特性
- 7. jdk1.8新特性
- 8. 一个影响力大、实战、干货的SEO案例
- 9. JDK1.8 新特性（全）
- 10. JDK1.8的新特性