Java14 都来了，你还不会用 Java8吗？

代码宇宙

发布于 2023-02-23 02:13:26

35300

代码可运行

文章被收录于专栏：代码宇宙代码宇宙

运行总次数：0

代码可运行

前言

Java 8 于2014年3月18日发布，并且成为主流的 Java，如今，虽然 Java 14 都已经发布了，但是开发者和公司选择的版本依旧是经久不衰的 Java 8 版本，如果你还不了解这些新特性，是时候学习一下了。

Java 8 更新的一些重要功能一览

Iterable 接口中的 forEach() 方法
接口中的默认方法和静态方法
功能接口和 Lambda 表达式
用于集合上批量数据操作的 Java Stream API
Java 时间 API
集合 API 的改进
并发 API 改进
Java IO改进
其他核心 API 改进

下面来简要了解一下这些Java 8功能。我将提供一些代码片段以更好地理解，因此，如果要在Java 8中运行程序，则必须按照以下步骤设置Java 8环境。

下载并安装JDK8。像其他Java版本一样，安装也很简单，运行下面的示例，必须要安装 JDK 环境。

下载最新的 IDEA 开发环境，这里我不推荐使用 Eclipse ，但是如果你有使用 Eclipse 习惯，那我在这里推荐你可以尝试 IDEA，因为它真的太棒啦~

Iterable 接口中的 forEach()方法

在 Java 8 以前，每当需要遍历 Collection 时，就需要创建一个 Iterator 来进行迭代 Collection 对象，然后针对 Collection 中的每个元素将业务逻辑循环在一起。如果迭代器使用不正确，可能会抛出 ConcurrentModificationException。

Java 8 在接口中引入了forEach方法，java.lang.Iterable因此在编写代码时，我们仅关注业务逻辑。forEach方法将java.util.function.Consumer对象作为参数，因此有助于将我们的业务逻辑放在一个可以重用的单独位置。让我们通过简单的示例查看forEach用法。

package com.journaldev.java8.foreach;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.lang.Integer;

public class Java8ForEachExample {

    public static void main(String[] args) {

        //creating sample Collection
        List<Integer> myList = new ArrayList<Integer>();
        for(int i=0; i<10; i++) myList.add(i);

        //traversing using Iterator
        Iterator<Integer> it = myList.iterator();
        while(it.hasNext()){
            Integer i = it.next();
            System.out.println("Iterator Value::"+i);
        }

        //traversing through forEach method of Iterable with anonymous class
        myList.forEach(new Consumer<Integer>() {

            public void accept(Integer t) {
                System.out.println("forEach anonymous class Value::"+t);
            }

        });

        //traversing with Consumer interface implementation
        MyConsumer action = new MyConsumer();
        myList.forEach(action);

    }

}

//Consumer implementation that can be reused
class MyConsumer implements Consumer<Integer>{

    public void accept(Integer t) {
        System.out.println("Consumer impl Value::"+t);
    }


}

代码的行数可能会增加，但是forEach方法有助于将迭代逻辑和业务逻辑放在不同的位置，从而使关注点和代码更清晰地分离。

接口中的默认方法和静态方法

如果仔细阅读forEach方法的详细信息，会注意到它是在Iterable接口中定义的，但我们知道接口不能具有方法主体。从Java 8开始，接口已增强为具有实现的方法。我们可以使用default和static关键字来创建带有方法实现的接口。Iterable接口中的forEach方法实现为：

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

我们知道Java不会在Class中提供多重继承，因为它会导致Diamond问题。由于接口现在类似于抽象类，因此现在如何使用接口处理它。解决方案是在这种情况下编译器将引发异常，我们将不得不在实现接口的类中提供实现逻辑。

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface1 {

    void method1(String str);

    default void log(String str){
        System.out.println("I1 logging::"+str);
    }

    static void print(String str){
        System.out.println("Printing "+str);
    }

    //trying to override Object method gives compile-time error as
    //"A default method cannot override a method from java.lang.Object"

//    default String toString(){
//        return "i1";
//    }

}

package com.journaldev.java8.defaultmethod;

@FunctionalInterface
public interface Interface2 {

    void method2();

    default void log(String str){
        System.out.println("I2 logging::"+str);
    }

}

注意，两个接口都有一个带有实现逻辑的通用方法log()。

package com.journaldev.java8.defaultmethod;

public class MyClass implements Interface1, Interface2 {

    @Override
    public void method2() {
    }

    @Override
    public void method1(String str) {
    }

    //MyClass won't compile without having it's own log() implementation
    @Override
    public void log(String str){
        System.out.println("MyClass logging::"+str);
        Interface1.print("abc");
    }

}

如你所见， Interface1 具有在 MyClass.log() 方法实现中使用的静态方法实现。Java 8 在 Collection API 中大量使用默认和静态方法，并且添加了默认方法，以便使 JDK 8 之前的代码保持向后兼容。

如果层次结构中的任何类都具有具有相同的方法，则默认方法将变得无关紧要。由于任何实现接口的类都已经具有 Object 作为超类，因此如果接口中具有 equals()，hashCode() 默认方法，它将变得无关紧要。这就是为什么为了更清楚起见，不允许接口具有Object默认方法。

有关Java 8接口特性的完整详细信息，请阅读 Java 8接口更改。

功能接口和Lambda表达式

如果你注意到上述接口代码，则会注意到 @FunctionalInterface 注解。该功能接口是Java 8 中引入的新概念。具有一种抽象方法的接口就变成了功能接口。我们不需要使用 @FunctionalInterface 注解将接口标记为Functional Interface。@FunctionalInterface 注解是一种避免在功能接口中意外添加抽象方法的工具。您可以将其视为 @Override 批注，并且是使用它的最佳实践。java.lang.Runnable 使用单个抽象方法 run() 是功能接口的一个很好的例子。

功能接口的主要优点之一是可以使用 lambda 表达式实例化它们。在 Java 8 之前，可以用匿名类实例化一个接口，但是代码看起来很庞大。

Runnable r = new Runnable(){
    @Override
    public void run() {
            System.out.println("My Runnable");
    }};

由于功能接口只有一种方法，因此 lambda 表达式可以轻松提供该方法的实现。只需要提供方法参数和业务逻辑。例如，可以使用 lambda 表达式编写上面的实现：

Runnable r1 = () -> {
            System.out.println("My Runnable");
        };

如果方法实现中只有一条语句，那么我们也不需要大括号。例如，上面的Interface1匿名类可以使用lambda实例化，如下所示：

Interface1 i1 = (s) -> System.out.println(s);

i1.method1("abc");

因此，lambda 表达式是轻松创建功能接口的匿名类的一种方法。使用 lambda 表达式对于代码运行没有任何的影响，因此要谨慎谨慎使用它，因为我们并不介意编写一些额外的代码行。

新包装 java.util.function 添加了带有功能接口束的，以提供 lambda 表达式和方法引用的目标类型。Lambda 表达式是一个非常复杂的话题，后续我会编写一篇文章专门针对 lambda 表达式。

您可以在 Java 8 Lambda Expressions Tutorial 中阅读完整的教程。

用于集合上批量数据操作的Java Stream API

java.util.stream 是Java 8中添加的一个新内容，以对该集合执行类似过滤/映射/遍历的操作。Stream API 将允许顺序执行和并行执行。这对我来说是非常好用的一个功能，因为我经常处理 Collections，而且通常使用很多的数据进行过滤数据，遍历数据，stream 就完美的解决了这个问题。

Collection 接口已使用 stream() 和 parallelStream() 默认方法进行了扩展，以获取用于顺序执行和并行执行的 Stream ，用一个简单的例子看看它们的用法。

package com.journaldev.java8.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class StreamExample {

    public static void main(String[] args) {

        List<Integer> myList = new ArrayList<>();
        for(int i=0; i<100; i++) myList.add(i);

        //sequential stream
        Stream<Integer> sequentialStream = myList.stream();

        //parallel stream
        Stream<Integer> parallelStream = myList.parallelStream();

        //using lambda with Stream API, filter example
        Stream<Integer> highNums = parallelStream.filter(p -> p > 90);
        //using lambda in forEach
        highNums.forEach(p -> System.out.println("High Nums parallel="+p));

        Stream<Integer> highNumsSeq = sequentialStream.filter(p -> p > 90);
        highNumsSeq.forEach(p -> System.out.println("High Nums sequential="+p));

    }

}

如果你运行示例代码，将获得如下输出：

High Nums parallel=91
High Nums parallel=96
High Nums parallel=93
High Nums parallel=98
High Nums parallel=94
High Nums parallel=95
High Nums parallel=97
High Nums parallel=92
High Nums parallel=99
High Nums sequential=91
High Nums sequential=92
High Nums sequential=93
High Nums sequential=94
High Nums sequential=95
High Nums sequential=96
High Nums sequential=97
High Nums sequential=98
High Nums sequential=99