有点干货 | Jdk1.8新特性实战篇(41个案例)

本文主要是介绍有点干货 | Jdk1.8新特性实战篇(41个案例)，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

作者：小傅哥
博客：https://bugstack.cn - 原创系列优质专题文章

沉淀、分享、成长，让自己和他人都能有所收获！

前言

一直想把jdk1.8的新特性整理下，恰好看到老外的git(文后有链接)，在这个结构上继续完善了说明和功能，做了41个单元测试案例，方便新人学习。以下内容很干，对于一个萌新小白来说，学习jdk1.8的新特性，基本看一遍就知道个7788了，在熟读两遍最后跟着写一遍，那么在实际项目中就可以运用了。不过！新特性，虽然很好。但如果想用，那么自己一定要看看相对应的源码并多练习，否则真的容易给自己搞晕，又很难阅读。

零、回顾一个抽象类

在jdk1.8之前，因为接口里只能做方法定义不能有方法的实现，因此我们通常会在抽象类里面实现默认的方法｛一般这个默认的方法是抽象后公用的方法，不需要每一个继承者都去实现，只需调用即可｝。就像下面这样；

在定义的时候；

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
}

一、在接口中提供默认的方法实现（有点像抽象类）

在jdk1.8里面，不仅可以定义接口，还可以在接口中提供默认的实现。这一个小小的改变却让整个抽象设计都随着改变了！

在定义的时候；{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));
}

在使用的时候(二)；如果只是一里面方式这么使用，那么就没多大意思了。我一直说过；好的代码都很骚！

1. a; a是一个入参名称，可以其他任何名字
2. ->a*a； 箭头指向是具体的实现
3. 但是，这样其实不太适合加日志了

@Test
public void test_02() {
    // 入参a 和 实现
    IFormula formula = a -> a * a;
    System.out.println(formula.calculate(2));
    System.out.println(formula.sqrt(2));
}

二、Lambda 表达式

因为有接口中可以增加默认的方法实现，那么Java肯定是因为要简化开发才出现的这么个设计。所以你会从各个我们以前的List、Set等等所有接口中看到默认的方法实现。

从一段熟悉的排序列子入手

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));

为了追求极致，我们还可以让它再短点：｛当然过你的实现不是一行代码，那么不能这么干｝

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());

二、函数式接口 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);

}

1. 先来一段传统方式 & 简单易懂哈，因为看习惯了

IConverter<String, Integer> converter01 = new IConverter<String, Integer>() {
@Override
public Integer convert(String from) {
    return Integer.valueOf(from);
}

1. 稍微简化下，化个妆 & (form)，只有一个参数括号可以不要

IConverter<String, Integer> converter02 = (from) -> {
    return Integer.valueOf(from);
};

1. 继续简化，因为他的实现只有一行代码，可以更加简短

IConverter<String, Integer> converter03 = from -> Integer.valueOf(from);

1. 还能短点，其实这个另类属于下一段的内容了，先放这有个印象

IConverter<Integer, String> converter04 = String::valueOf;

三、方法和构造函数的便捷引用

在上面我们先加了印象片段 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 方法。

四、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 表达式中访问的，上面这段代码将无法被编译通过。

五、内置的函数式接口

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
}

六、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));
}

七、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
}

八、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（）。

九、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
}

十、日期 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.

十一、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

推荐阅读

• 重学 Java 设计模式：实战工厂方法模式
• 重学 Java 设计模式：实战抽象工厂模式
• 这么折腾学习毕业进大厂不是问题
• 工作两年简历写的差教你优化
• 讲一下我自己的学习路线，给你一些参考

这篇关于有点干货 | Jdk1.8新特性实战篇(41个案例)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！