Java 8 新特性指南

你的名字 2022-03-22 07:24 234阅读 0赞

### 文章目录 ###

*   *  1、简介
     *  2、接口的默认方法（Default Methods for Interfaces）
     *  3、Lambdas 表达式（Lambda expressions）
     *  4、函数式接口（Functional Interfaces\#）
     *  5、方法和构造器引用（Method and Constructor References）
     *  6、lambda 作用域（Lambda Scopes ）
     *   *  访问局部变量
         *  访问字段和静态变量
         *  访问默认接口方法
     *  7、内置功能接口（Built-in Functional Interfaces）
     *   *  谓词（Predicates）
         *  函数（Functions）
         *  Suppliers
         *  Consumers
         *  Comparators
         *  Optionals
     *  8、流（Streams）
     *   *  Filter
         *  Sorted
         *  Map
         *  Match
         *  Count
         *  Reduce
     *  9、并行流（Parallel Streams）
     *   *  顺序排序（顺序排序）
         *  并行排序（Parallel Sort）
     *  10、Map
     *  12、Date API
     *   *  Clock
         *  Timezones
         *  LocalTime
         *  LocalDate
         *  LocalDateTime
     *  13、注解（Annotations）

## 1、简介 ##

Java 8 已经发布很久了，事实已经证明 Java 8 是一次重大的版本升级。在网上已经有很多介绍Java 8 新特性的文章，我也看了不少，都挺好的。为什么我还要再写关于Java 8 的文章呢，原因很简单：「我需要」。有些“轮子”还是需要重复造的，比如“学习”这个轮子，别人文章写得很棒，那是因为别人用心学习和总结的成果，你虽然看到这些文章产生了一些共鸣，但这些技能你真正掌握了吗？

虽然工作中也用到了一些，关于Java 8 的新特性，但也是简单实用而已。我的目的很简单就是系统梳理一下这些知识，亲身体验一下这些特性，多思考一下为什么，我相信这个重复造轮子的过程，自己会收获很多。

本文是翻译的文章，原文地址为：[https://winterbe.com/posts/2014/03/16/java-8-tutorial/][https_winterbe.com_posts_2014_03_16_java-8-tutorial]

## 2、接口的默认方法（Default Methods for Interfaces） ##

Java 8 给我们提供了 default 关键字，使用该关键字可以在接口中增加非抽象的方法实现，这个特性也被叫做 扩展方法（Extension Methods）

interface Formula {
        double calculate(int a);
    
        default double sqrt(int a) {
            return Math.sqrt(a);
        }
    }

计算公式接口除了定义了抽象计算方法 calculate，还定义了一个默认实现的方法 sqrt。具体类只需要实现抽象计算方法，默认方法 sqrt 可以直接使用。

Formula formula = new Formula() {
        @Override
        public double calculate(int a) {
            return sqrt(a * 100);
        }
    };
    
    formula.calculate(100);     // 100.0
    formula.sqrt(16);           // 4.0

该公式是作为匿名对象实现的，代码非常冗长：6行代码用于实现如此简单的 sqrt（a \* 100）。正如我们将在下一节中看到的，在Java 8中实现单个方法对象有一种更好的方法。

## 3、Lambdas 表达式（Lambda expressions） ##

我们先看一下java 8 之前如何对一个字符串List 排序：

//lambda expressions
            List<String> fruits = Arrays.asList("orange", "watermelon", "banana", "apple");
    
            //before java 8
            Collections.sort(fruits, new Comparator<String>() {
                @Override
                public int compare(String a, String b) {
                    return b.compareTo(a);
                }
            });

静态方法 Collections.sort 接受一个 list 和比较方法来对给定的list元素排序。  
我们总是需要创建匿名比较器传递给排序方法 sort 对集合元素进行排序。

而java 8 带来了更简洁的语法来实现，而不需要创建匿名对象，那就是 lambda 表达式：

Collections.sort(fruits, (String a, String b) -> {
        return b.compareTo(a);
    });

正如您所看到的，代码更短，更易于阅读。 但它可以变得更短：

Collections.sort(fruits, (String a, String b) -> b.compareTo(a));

对于一行方法体，我们可以省略大括号\{\}和return关键字，使它变得更简洁：

Collections.sort(fruits,(a,b)->a.compareTo(b));
    或
    Collections.sort(fruits,String::compareTo);

java编译器知道参数类型，因此也可以省略类型修饰它们。 接下来让我们深入了解lambda表达式如何被广泛使用的。

## 4、函数式接口（Functional Interfaces\#） ##

lambda表达式是如何符合 Java 类型系统的？每个lambda对应于一个给定的类型，用一个接口来说明，而这个被称为函数式接口（functional interface）的接口必须仅仅包含一个抽象方法声明。因此默认的方法并不是抽象的，你可以给你的函数式接口自由地增加默认的方法。

我们可以使用任意的接口作为lambda表达式，只要这个接口只包含一个抽象方法。为了保证你的接口满足需求，你需要增加 @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

请记住，如果省略@FunctionalInterface注释，代码也是有效的。

## 5、方法和构造器引用（Method and Constructor References） ##

通过使用静态方法引用可以进一步简化上面的示例代码：

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"

让我们看看::关键字如何为构造函数工作。 首先，我们定义一个具有不同构造函数的示例bean：

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

我们不是手动实现工厂，而是通过构造函数引用将所有内容粘合在一起：

PersonFactory<Person> personFactory = Person::new;
    Person person = personFactory.create("Peter", "Parker");

我们通过Person::new创建了一个 Person 构造器的引用。Java编译器通过匹配 PersonFactory.create 方法的签名自动选择合适的构造器。

## 6、lambda 作用域（Lambda Scopes ） ##

从lambda表达式访问外部作用域变量与匿名对象非常相似。 您可以从本地外部作用域以及实例字段和静态变量访问 final 变量。

### 访问局部变量 ###

lambda 表达式可以访问表达式外部的 final 局部变量

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 类型。 以下代码无法编译：

int num = 1;
    Converter<Integer, String> stringConverter =
            (from) -> String.valueOf(from + num);
    num = 3;

在lambda表达式里对 num 赋值也同样是被禁止的。

### 访问字段和静态变量 ###

与局部变量相比，我们对lambda表达式中的实例字段和静态变量都有读写访问权限。 这种行为在匿名对象中是众所周知的。

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

### 访问默认接口方法 ###

还记得前文中的公式示例吗？ 接口公式定义了一个默认方法sqrt，可以从包含匿名对象的每个公式实例访问该方法。 这不适用于lambda表达式。

无法从lambda表达式中访问默认方法。 以下代码无法编译：

Formula formula = (a) -> sqrt( a * 100);

## 7、内置功能接口（Built-in Functional Interfaces） ##

JDK 1.8 API 包含很多内置的功能接口。其中一些在旧的 Java 版本中就众所周知了，例如Comparator 以及 Runnable。通过@FunctionalInterface标记，这些现有的接口已被扩展为lambda所能支持的。

然而 Java 8 API 同样拥有众多新的功能接口来使你的使用更加简单。这些新接口中的一些从Google Guava 库中已经广为人知。即使你对此库很熟悉，你也应该仔细看看那些接口是如何通过一些有用的方法所扩展的。

### 谓词（Predicates） ###

谓词是一个参数的布尔值函数。 该接口包含各种默认方法，用于将谓词组合成复杂的逻辑术语（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();

### 函数（Functions） ###

函数接受一个参数并生成结果。 默认方法可用于将多个函数链接在一起（compose，andThen）。

Function<String, Integer> toInteger = Integer::valueOf;
    Function<String, String> backToString = toInteger.andThen(String::valueOf);
    
    backToString.apply("123");     // "123"

### Suppliers ###

Suppliers 产生一个给定的泛型类型的结果。区别于函数，Suppliers 不接受参数。

Supplier<Person> personSupplier = Person::new;
    personSupplier.get();   // new Person

### Consumers ###

Consumers 表示要对单个输入参数执行的操作。

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName);
    greeter.accept(new Person("Luke", "Skywalker"));

### Comparators ###

比较器在Java的旧版本中是众所周知的。 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

### Optionals ###

Optionals 不是功能接口，而是防止NullPointerException的一个很好的工具。

Optional 是对空或者非空的一个值的简单的容器。想象一下，一个应该返回非空值结果的方法却有时候什么也没返回。在Java 8 中，你将返回一个Optional 而不是null。

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"

## 8、流（Streams） ##

java.util.Stream表示可以在其上执行一个或多个操作的元素序列。 流操作是中间操作或终端操作。 当终端操作返回某种类型的结果时，中间操作会返回流本身，因此您可以连续链接多个方法调用。 流是在源上创建的，例如 列表或集合之类的java.util.Collection（不支持映射）。 流操作可以顺序执行或并行执行。

我们先来看看顺序流是如何工作的。 首先，我们以字符串列表的形式创建一个示例源：

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

扩展了Java 8中的集合，因此您可以通过调用Collection.stream（）或Collection.parallelStream（）来创建流。 以下部分介绍了最常见的流操作。

### Filter ###

过滤器接受谓词以过滤流的所有元素。 此操作是中间操作，它使我们能够对结果调用另一个流操作（forEach）。 ForEach接受为过滤流中的每个元素执行的使用者。 ForEach是一个终端操作。 它是无效的，所以我们不能调用另一个流操作。

stringCollection
        .stream()
        .filter((s) -> s.startsWith("a"))
        .forEach(System.out::println);
    
    // "aaa2", "aaa1"

### Sorted ###

Sorted是一个中间操作，它返回流的排序视图。 除非您传递自定义比较器，否则元素按自然顺序排序。

stringCollection
        .stream()
        .sorted()
        .filter((s) -> s.startsWith("a"))
        .forEach(System.out::println);
    
    // "aaa1", "aaa2"

请记住，sorted 真的仅仅对此stream创建一个排序的视图，它并不操纵背后的聚集（collection）。stringCollection 的顺序并未改变

### Map ###

中间操作映射通过给定函数将每个元素转换为另一个对象。 以下示例将每个字符串转换为大写字符串。 但您也可以使用map将每个对象转换为另一种类型。 结果流的泛型类型取决于传递给map的函数的泛型类型。

stringCollection
        .stream()
        .map(String::toUpperCase)
        .sorted((a, b) -> b.compareTo(a))
        .forEach(System.out::println);
    
    // "DDD2", "DDD1", "CCC", "BBB3", "BBB2", "AAA2", "AAA1"

### Match ###

可以使用各种匹配操作来检查某个谓词是否与流匹配。 所有这些操作都是终端并返回一个布尔结果。

boolean anyStartsWithA =
        stringCollection
            .stream()
            .anyMatch((s) -> s.startsWith("a"));
    
    System.out.println(anyStartsWithA);      // true
    
    boolean allStartsWithA =
        stringCollection
            .stream()
            .allMatch((s) -> s.startsWith("a"));
    
    System.out.println(allStartsWithA);      // false
    
    boolean noneStartsWithZ =
        stringCollection
            .stream()
            .noneMatch((s) -> s.startsWith("z"));
    
    System.out.println(noneStartsWithZ);      // true

### Count ###

Count是一个终端操作，返回流中元素的数量为 long 型。

long startsWithB =
        stringCollection
            .stream()
            .filter((s) -> s.startsWith("b"))
            .count();
    
    System.out.println(startsWithB);    // 3

### Reduce ###

该终端操作使用给定功能执行流的元素的减少。 结果是可选保持减少的值。

Optional<String> reduced =
        stringCollection
            .stream()
            .sorted()
            .reduce((s1, s2) -> s1 + "#" + s2);
    
    reduced.ifPresent(System.out::println);
    // "aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2"

## 9、并行流（Parallel Streams） ##

如上所述，流可以是顺序的或并行的。 对顺序流的操作在单个线程上执行，而并行流上的操作在多个线程上并发执行。

如下例子证明了通过使用并发流是如何简单地提高运算性能的。

首先，我们创建一个无重复元素的大的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());
    }

现在我们测量对此集合的流进行排序所需的时间。

### 顺序排序（顺序排序） ###

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("sequential sort took: %d ms", millis));
    
    // sequential sort took: 899 ms

### 并行排序（Parallel Sort） ###

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: 472 ms

正如您所看到的，两个代码片段几乎完全相同，但并行排序大约快了50％。 您所要做的就是将stream（）更改为parallelStream（）。

## 10、Map ##

如前所述，Map 不支持流。 相反，Map 现在支持各种新的和有用的方法来执行常见任务。

Map<Integer, String> map = new HashMap<>();
    
    for (int i = 0; i < 10; i++) {
        map.putIfAbsent(i, "val" + i);
    }
    
    map.forEach((id, val) -> System.out.println(val));

上面的代码应该是自我解释的：putIfAbsent阻止我们在null检查时写入额外的代码; forEach接受使用者对 Map 的每个值执行操作。

此示例显示如何使用函数在 Map 上计算代码：

ap.computeIfPresent(3, (num, val) -> val + num);
    map.get(3);             // val33
    
    map.computeIfPresent(9, (num, val) -> null);
    map.containsKey(9);     // false
    
    map.computeIfAbsent(23, num -> "val" + num);
    map.containsKey(23);    // true
    
    map.computeIfAbsent(3, num -> "bam");
    map.get(3);             // val33

接下来，我们将学习如何删除给定键的条目，前提是它当前映射到给定值：

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

另一种有用的方法

map.getOrDefault(42, "not found");  // not found

合并Map的元素非常简单：

map.merge(9, "val9", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9
    
    map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
    map.get(9);             // val9concat

如果不存在键的条目，则合并将键/值放入映射，或者将调用合并函数以更改现有值。

## 12、Date API ##

Java 8在java.time包下包含一个全新的日期和时间API。 新的Date API与Joda-Time库相当，但它不一样。 以下示例涵盖了此新API的最重要部分。

### Clock ###

Clock 提供对当前日期和时间的访问。 Clock 知道时区，可以使用而不是System.currentTimeMillis（）来检索当前的毫秒数。 时间线上的这个瞬时点也由Instant类表示。 Instants可用于创建遗留的java.util.Date对象。

Clock clock = Clock.systemDefaultZone();
    long millis = clock.millis();
    
    Instant instant = clock.instant();
    Date legacyDate = Date.from(instant);   // legacy 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点或17:30:15。 以下示例为上面定义的时区创建两个本地时间。 然后我们比较两次并计算两次之间的小时和分钟差异。

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年3月11日。 它是不可变的，并且与LocalTime完全类似。 该示例演示了如何通过添加或减少天，月或年来计算新日期。 请记住，每个操作都会返回一个新实例。

LocalDate today = LocalDate.now();
    LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
    LocalDate yesterday = tomorrow.minusDays(2);
    
    LocalDate independenceDay = LocalDate.of(2014, Month.JULY, 4);
    DayOfWeek dayOfWeek = independenceDay.getDayOfWeek();
    System.out.println(dayOfWeek);    // FRIDAY

从字符串解析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表示日期时间。 它将上面部分中显示的日期和时间组合成一个实例。 LocalDateTime是不可变的，其工作方式与LocalTime和LocalDate类似。 我们可以利用从日期时间检索某些字段的方法：

LocalDateTime sylvester = LocalDateTime.of(2014, Month.DECEMBER, 31, 23, 59, 59);
    
    DayOfWeek dayOfWeek = sylvester.getDayOfWeek();
    System.out.println(dayOfWeek);      // WEDNESDAY
    
    Month month = sylvester.getMonth();
    System.out.println(month);          // DECEMBER
    
    long minuteOfDay = sylvester.getLong(ChronoField.MINUTE_OF_DAY);
    System.out.println(minuteOfDay);    // 1439

通过时区的附加信息，它可以转换为瞬间。 可以轻松地将实例转换为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

格式化日期时间就像格式化日期或时间一样。 我们可以使用自定义模式创建格式化程序，而不是使用预定义的格式。

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是不可变的和线程安全的。

## 13、注解（Annotations） ##

Java 8中的注解是可重复的。 让我们直接深入了解一个例子来解决这个问题。

首先，我们定义一个包装器注释，它包含实际注释的数组：

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

Java 8允许我们通过声明注解 @Repeatable 来使用相同类型的多个注解。

**变式1：使用容器注解**

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

**变式2：使用可重复的注解**

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

使用变式2，Java编译器可以隐式地设置 @Hints注解。这对于通过反射来阅读注解信息是很重要的。

int 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，它允许直接访问所有带注解的@Hint注解。

此外，在Java8中对注解的使用被扩展到两个新的targets：

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

> 至此，Java 8 新特性指南就结束了，本文简单的介绍了一些新特性，还是比较使用的，在工作中如果需要用到以上的类似场景，不妨使用新特性试一试，也许会给你带来不一样的效果。Java 12 发布在即，再不学习真要掉队了。。。

[https_winterbe.com_posts_2014_03_16_java-8-tutorial]: https://winterbe.com/posts/2014/03/16/java-8-tutorial/