从 Java8 到 Java11 再到 Java17 的新特性(1)

从 JDK8 之后，Java 的更新策略改为以时间驱动的方式，每六个月发布一个新的Java版本，每三年发表一个长期支持版本。一般如果要对旧 JDK 进行升级，都会选择长期支持版，JDK11 和最近更新的 JDK17 是长期支持版本。但是由于商业项目更看重稳定性，更新 JDK 带来的收益不大，大多数人不愿意踩坑去更新 JDK。因此，很多人都只是从新闻了解到新 JDK 的新特性，平常开发没有接触到，甚至有些在用 JDK8 的人连 JDK8 的新特性都用不利索或者直接就不知道。其实许多新特性是可以简化我们的开发，能让我们以更优雅的方式实现功能。接下来我将分三篇文章分别简单介绍 JDK8、JDK9-JDk11 和 JDK12-JDK17 在编码方面的一些新功能，至于虚拟机的改进和其他部门这里暂不做讨论。

先从 Java8 开始说起，看看部分常用的新特性。
本文源码地址：code-note

1. Lambda 表达式

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中），让匿名内部类的写法更简便。

例子：

public class LambdaTest {

    public LambdaTest() {
    }
    public LambdaTest(String str) {
        //use param str to do something
    }

    public static void interfaceTest(SingleFncInterface singleFunInterface) {
        singleFunInterface.doSomething("123");
    }

    public void simpleMenthod(String str) {
        System.out.println("simple method. str is:");
    }

    public static void staticMenthod(String str) {
        System.out.println("static menthod. str is:");
    }
}
/**
 * 单函数接口
 */
@FunctionalInterface
interface SingleFncInterface {
    void doSomething(String str);

    default void print() {
        System.out.println("default method.");
    }
}

以上 SingleFncInterface 是一个典型的函数式接口，只包含一个抽象方法，可以加上 @FunctionalInterface 注解标记，限制只允许定义一个抽象方法。

/**
 * Lambda 本质就是单函数接口
 */
@Test
public void singleFunTest() {
    //作为参数的形式
    LambdaTest.interfaceTest((String str) -> {
        System.out.println("single function interface. param:" + str);
    });

    //SingleFncInterface s = (String str) -> System.out.println(str);
	SingleFncInterface s = str -> System.out.println(str);
    s.doSomething("123");

    //简化形式，方法引用
    //LambdaTest.interfaceTest(item -> System.out.println(item));
    LambdaTest.interfaceTest(System.out::println);
}

可以看出 lambda 表达式的语法格式是如：(parameters) -> expression/statements，特殊的还有更加简化的方法引用方式。

方法引用可分为三种，静态、实例和构造引用，使用例子如下：

/**
 * 方法引用
 */
@Test
public void refTest() {
    //静态引用。意思就是用 String 的 valof() 方法来实现 Function 接口的 apply 方法
    Function<Integer, String> fun = String::valueOf;
    String apply = fun.apply(100);
    System.out.println(apply);

    //静态引用
    SingleFncInterface sfi1 = LambdaTest::staticMenthod;

    //实例引用
    LambdaTest lambdaTest = new LambdaTest();
    SingleFncInterface sfi2 = lambdaTest::simpleMenthod;

    //构造引用，带参数
    SingleFncInterface sfi3 = LambdaTest::new;

    //构造引用，不带参数
    Runnable runnable = LambdaTest::new;
    //runnable.run();//单函数 Runnable 接口 run 方法由 LambdaTest 构造实现
}

根据输入和返回参数的不同，JDK 中提供了四种类型的函数式接口：

/**
 * 四种类型函数式接口
 */
@Test
public void funTest() {
    /**
     * Function<T, R>
     * 调用方法 R apply(T t);
     * T：入参类型，R：出参类型
     */
    Function<Integer, Integer> function = n -> n*n;
    Integer apply = function.apply(10);
    System.out.println(apply);

    /**
     * Consumer<T>
     * 调用方法：void accept(T t);
     * T：入参类型；没有出参
     */
    Consumer<String> consumer = System.out::println;
    consumer.accept("output msg.");

    /**
     * Supplier<T>
     * 调用方法：T get();
     * T：出参类型；没有入参
     */
    Supplier<Integer> supplier = () -> 10*10;
    Integer integer = supplier.get();
    System.out.println(integer);

    /**
     * Predicate<T>
     * 调用方法：boolean test(T t);
     * T：入参类型；出参类型是Boolean
     */
    Predicate<Integer> predicate = num -> num>10;//是否大于10
    boolean test = predicate.test(20);
    System.out.println(test);
}

2. 接口默认方法

Java8 允许在接口中添加一个或者多个默认方法，在 SingleFncInterface 接口中 print() 就是一个默认方法。增加默认方法是为了给接口添加新方法的同时不影响已有的实现，不需要修改全部实现类。

@FunctionalInterface
interface SingleFncInterface {
    void doSomething(String str);

    default void print() {
        System.out.println("default method.");
    }
}

3. Optional 类

在 Java8 之前，空指针异常是编码时最需要注意的异常，我们往往都需要手动对变量进行 null 值判断，对可能的空指针异常进行捕获处理。Java8 提供的 Optional 类可以以比较优雅的方式进行空值判断，解决空指针异常。

import org.junit.Before;
import org.junit.Test;

import java.util.Optional;

public class OptionalExample {

    private Person person;
    private Car car;
    private Insurance insurance;

    @Before
    public void init() {
        insurance = new Insurance("Tesla");
        car = new Car(Optional.of(insurance));
        person = new Person(Optional.of(car));
    }

    @Test
    public void test1() {
        //允许传递为 null 的参数
        Optional<Insurance> insurance = Optional.ofNullable(this.insurance);
        Optional<String> s = insurance.map(insurance1 -> insurance1.getName());
        System.out.println(s);
    }

    @Test
    public void test2() {
        Optional<Person> person = Optional.of(this.person);
        String name = person.flatMap(Person::getCar)
                .flatMap(Car::getInsurance)//拿到封装的 Optional<Car>
                .map(Insurance::getName)//直接拿到值
                .orElse("ubknow");
        System.out.println(name);
    }

    @Test
    public void test3() {
        Optional<Car> c = Optional.empty();
        Optional<String> s = c.flatMap(Car::getInsurance)
                .map(Insurance::getName);
        System.out.println(s);
        String unknow = s.orElse("unknow");
        System.out.println(unknow);
    }

}

class Person {
    private Optional<Car> car;

    public Person(Optional<Car> car) {
        this.car = car;
    }
    public Optional<Car> getCar() {
        return car;
    }
}

class Car {
    private Optional<Insurance> insurance;

    public Car(Optional<Insurance> insurance) {
        this.insurance = insurance;
    }
    public Optional<Insurance> getInsurance() {
        return insurance;
    }
}

class Insurance {
    private String name;

    public Insurance(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

1
2
3

Optional<Insurance> insurance = Optional.of(this.insurance)
// this.insurance 为 null 返回 Optional.empty
Optional<Insurance> insurance = Optional.ofNullable(this.insurance)

简单来说，如果想得到一个非 null 值的 Optional 使用 Optional.of，允许 null 值的话使用 Optional.ofNullable;

String name = person.flatMap(Person::getCar)
                .flatMap(Car::getInsurance)
                .map(Insurance::getName)
                .orElse("unknown");

对于返回一个 Optional 结果集需要使用 flatMap，比如 Person::getCar 方法和 Car::getInsurance，只要单一转换的使用 map，例如 Insurance::getName，如果是 empty 返回 orElse 的内容。

4. Stream 流处理

流 Stream 通过声明的方式来处理数据，可以在管道的节点上对数据进行排序、聚合、筛选、去重和截取等等操作。

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {

    /**
     * 初始化集合
     */
    List<Fruit> fruits = new ArrayList<>(Arrays.asList(
            new Fruit("apple"),
            new Fruit("banana"),
            new Fruit("orange")
    ));

    /**
     * 遍历
     */
    @Test
    public void outputTest() {
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);

        integers.forEach(System.out::print);
        System.out.println();
        integers.stream().forEach(System.out::print);
        System.out.println();
        //并行流底层使用Fork/Join框架实现，异步处理，输出不一定是12345
        integers.parallelStream().forEach(System.out::print);
        System.out.println();

    }

    /**
     * 映射
     */
    @Test
    public void mapTest() {
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        //映射每个元素操作，生成新的结果
        List<Integer> collect = integers.stream().map(n -> n * n).collect(Collectors.toList());
        System.out.println(collect);

        List<String> fruitList = fruits.stream().map(obj -> obj.name="I like ".concat(obj.name)).collect(Collectors.toList());
        System.out.println(fruitList);
    }

    /**
     * 排序、过滤、限制
     */
    @Test
    public void filterTest() {
        List<Integer> integers = Arrays.asList(2, 3, 1, 4, 8, 5, 9, 5);
        List<Integer> collect = integers.stream()
                //.sorted()//排序
                .sorted((x, y) -> y - x)
                .distinct()//去重
                .filter(n -> n < 6)//小于6的数
                .limit(3)//只截取3个元素
                .collect(Collectors.toList());
        System.out.println(collect);
    }

    /**
     * 聚合和统计
     */
    @Test
    public void mergeTest() {
        List<String> strings = Arrays.asList("Hello", " ", "world", "!");
        String collect = strings.stream().collect(Collectors.joining(""));
        System.out.println(collect);

        List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
        IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

        System.out.println("列表中最大的数 : " + stats.getMax());
        System.out.println("列表中最小的数 : " + stats.getMin());
        System.out.println("所有数之和 : " + stats.getSum());
        System.out.println("平均数 : " + stats.getAverage());
    }

}

class Fruit {
    public Fruit(String name) {
        this.name = name;
    }
    String name;

    public void setName(String name) {
        this.name = name;
    }
}

4. Base64 工具

Java 8 内置了 Base64 编码的编码器和解码器，支持三种编解码方式。

import org.junit.Test;
import java.io.UnsupportedEncodingException;
import java.util.Base64;

public class Base64Example {
    @Test
    public void test() throws UnsupportedEncodingException {
        //基本
        String s1 = Base64.getEncoder().encodeToString("base64test".getBytes("utf-8"));
        System.out.println(s1);
        System.out.println(new String(Base64.getDecoder().decode(s1), "utf-8"));

        //URL
        String s2 = Base64.getUrlEncoder().encodeToString("base64test".getBytes("utf-8"));
        System.out.println(s2);

        //Mime
        String s3 = Base64.getMimeEncoder().encodeToString("base64test".getBytes("utf-8"));
        System.out.println(s3);
    }
}

5. 新的日期和时间工具

在过去，Java 处理日期和时间我们一般是用 java.util.Date、java.util.Calendar 配合 java.text.SimpleDateFormat 来使用的，缺点是易用性差，线程不安全，不支持时区，新的日期和时间 API 解决了这些问题。

import org.junit.Test;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class TimeExample {

    @Test
    public void test() {
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime);

        LocalDate localDate = LocalDate.now();
        System.out.println(localDate);

        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime);
    }

    @Test
    public void test1() {
        LocalDateTime localDateTime = LocalDateTime.of(2021, 6, 1, 10, 30);
        System.out.println(localDateTime);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format = localDateTime.format(formatter);
        System.out.println(format);

        LocalDateTime parse = LocalDateTime.parse("2021-01-01 12:00:00", formatter);
        System.out.println(parse);
    }
}

6. CompletableFuture 异步编程

在 Java8 之前 Future 接口提供了异步执行任务的能力，但对于结果的获取只能通过阻塞或者轮询的方式。为了增强异步编程的功能，Java8 添加了 CompletableFuture 类，CompletableFuture 类实现了 CompletionStage 和 Future 接口，默认使用 ForkJoinPool.commonPool() 线程池。

commonPool 是当前 JVM（进程）上的所有 CompletableFuture、并行 Stream 共享的，commonPool 的目标场景是非阻塞的 CPU 密集型任务，其线程数默认为 CPU 数量减1，所以对于我们用 java 常做的 IO 密集型任务，默认线程池是远远不够使用的；在双核及以下机器上，默认线程池又会退化为为每个任务创建一个线程，相当于没有线程池。所以使用 CompletableFuture 时要根据业务决定是否需要自定义线程池。

在 CompletableFuture 中带有 Async 的都是异步方法，get 方法是同步的。

@Test
public void futureTest() throws ExecutionException, InterruptedException, TimeoutException {
    //单纯地返回一个值
    CompletableFuture<String> future = CompletableFuture.completedFuture("msg");
    System.out.println(future.get());

    //直接进行运算并返回
    CompletableFuture<Integer> supplyAsync = CompletableFuture.supplyAsync(() -> {
        try {
            Thread.sleep(2500L);
            //Thread.sleep(1000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1 + 1;
    });
    //是否执行完毕
    System.out.println(supplyAsync.isDone());
    //立刻返回执行结果或异常，否则返回指定值
    System.out.println(supplyAsync.getNow(1));
    //设置超时
    System.out.println(supplyAsync.get(2, TimeUnit.SECONDS));
}

对于多步骤的处理用 thenApply

@Test
public void apply() throws ExecutionException, InterruptedException {
    //多步骤处理，一个步骤处理完把结果返回给下一步继续处理，同步 thenApply，异步 thenApplyAsync
    CompletableFuture<Integer> future = CompletableFuture.completedFuture(1)
            .thenApply(i -> i + 2)
            .thenApplyAsync(i -> i + 3)
            //计算完毕后的处理，不影响 get 返回值
            .whenCompleteAsync((result, exception) -> {
                result *= 10;
                System.out.println("calculate result:" + result);
            });
    System.out.println(future.get());
}

组合方法用 thenCompose

@Test
public void thenComposeExample() throws ExecutionException, InterruptedException {
    String original = "Message";
    //将字符串转换大写，得到结果再转换小写，再组合起来
    CompletableFuture cf = CompletableFuture.completedFuture(original)
            .thenApply(s -> s.toUpperCase())
            .thenCompose(upper -> CompletableFuture.completedFuture(original)
                    .thenApply(s -> s.toLowerCase())
                    .thenApply(s -> upper + s));
    System.out.println(cf.get());
}

等待多个任务一起执行完毕再进行处理可以使用 allOf 方法

@Test
public void allof() throws ExecutionException, InterruptedException {
    List<Integer> integers = List.of(1, 2, 3);
    List<CompletableFuture<Integer>> futureList = integers.stream()
                    .map(item -> CompletableFuture.completedFuture(item).thenApplyAsync(num -> num * num))
                    .collect(Collectors.toList());
    CompletableFuture<Void> allof = CompletableFuture
            .allOf(futureList.toArray(new CompletableFuture[futureList.size()]))
            .whenCompleteAsync((result, exception) -> {
                futureList.forEach(cf -> {
                    System.out.println(cf.getNow(0));
                });
            });
    //handle 住看输出结果，因为是上面都用异步的，这里不等很可能看不到输出
    allof.get();
}

从 Java8 到 Java11 再到 Java17 的新特性(1)

从 Java8 到 Java11 再到 Java17 的新特性(1)

1. Lambda 表达式

2. 接口默认方法

3. Optional 类

4. Stream 流处理

4. Base64 工具

5. 新的日期和时间工具

6. CompletableFuture 异步编程

7. 参考