Inside Java Newscast #1 深度解读

本文是 Inside Java Newscast #1 的个人体验与解读。视频地址：点击这里

⎯⎯⎯⎯⎯⎯ Chapters ⎯⎯⎯⎯⎯⎯

• 0:00 - Intro
• 0:57 - Java 16 – Intro
• 1:16 - Java 16 – Records
• 1:43 - Java 16 – Type Pattern Matching
• 1:58 - Java 16 – Sealed Classes - Preview
• 2:25 - Java 16 – Stream API
• 2:51 - Java 16 – HTTP/2 API
• 3:14 - Java 16 – Unix Domain Sockets
• 3:32 - Java 16 – Project Panama (Incubating)
• 4:07 - Java 16 – JDK Flight Recorder
• 4:39 - Java 16 – jpackage
• 5:02 - Java 16 – Performance
• 5:23 - Java 16 – Security
• 5:48 - Java 16 – Ports
• 5:55 - Java 16 – Deprecations/Limitations
• 6:49 - Java 16 – Outro
• 7:08 - Java 17
• 7:22 - Java 17 – Another Port
• 7:34 - Java 17 – Applet for Removal
• 7:55 - Java 17 – Sealed Classes
• 8:12 - Outro

Java 16 – Records

相关 JEP 地址：

• JEP 359: Records(Preview)
• JEP 384: Records (Second Preview)
• JEP 395: Records

Records 这个特性我仔细研究过实现：参考我写的另一篇文章Java Record 的一些思考 - 默认方法使用以及基于预编译生成相关字节码的底层实

简单说来其实就是（编译后查看下字节码就能看出来），在编译后，根据 Record 源码插入相关域与方法的字节码，包括：

1. 自动生成的 private final field
2. 自动生成的全属性构造器
3. 自动生成的 public getter 方法

4. 自动生成的 hashCode()，equals()，toString() 方法：

   1. 从字节码可以看出，这三个方法的底层实现是 invokeDynamic 另一个方法
   2. 调用的是 ObjectMethods.java 这个类中的 bootstrap 方法

这个还让我闹了个笑话，我以为这个是 Project Valhala 的 Inline Object 已经实现了（参考我的这个系列： JEP 尝鲜系列），还去 StackOverflow 问，这个 Record 为啥能有 wait() 方法，并且可以进行 synchronized 同步（因为如果是 Project Valhala 的 Inline Object 的话是没有普通类的对象头的，没法用普通类对象的方法实现同步），结果。。。。。最后还是 Goetz 大佬一眼就看出我是误会了：

Record 这个特性当初是为了适应什么场景设计的，以及某些设计为何被舍弃，可以参考 Gotez 大佬的这篇文章 java-14-feature-spotlight. 其重中主要的看点总结如下：

1.Java Records 最常用于的地方就是方法多个返回结果，原来我们可能需要用 Apache-commons 里面的 Pair 或者 Tuple 这样的对象封装，或者自己新建一个类型。现在可以使用 Record。

2.第二个常见应用即在 Stream 中传递的过程中保持原有对象，并且减少运算，例如 Stream 排序：

List topN
        = players.stream()
             .sorted(Comparator.comparingInt(p -> getScore(p)))
             .limit(N)
             .collect(toList());

这么写的话，每次作比较都会调用一次 getScore(p)，这个调用次数是 O(n^2)。利用 Record 可以用比较少的代码和改动实现减少运算：

record PlayerScore(Player player, Score score) {
    // convenience constructor for use by Stream::map
    PlayerScore(Player player) { this(player, getScore(player)); }
}

List topN
    = players.stream()
             .map(PlayerScore::new)
             .sorted(Comparator.comparingInt(PlayerScore::score))
             .limit(N)
             .map(PlayerScore::player)
             .collect(toList());

最后再推荐下我写的这篇关于 Record 的序列化的一些解析和思考：Java Record 的一些思考 - 序列化相关

Java 16 – Type Pattern Matching

相关 JEP 地址：

• JEP 305: Pattern Matching for instanceof (Preview)
• JEP 375: Pattern Matching for instanceof (Second Preview)
• JEP 394: Pattern Matching for instanceof

类型模式匹配一直是一个呼声很高的特性，如果和下一小节的 Sealed Class 特性 以及 Patterns in switch 结合起来使用会有更好的效果，这个我们在下一节会更详细的说明.

Nicolai 对 Type Pattern Matching 的说明

Nicolai 的这篇文章 对 Type Pattern Matching 的说明非常详细，总结如下：

原来需要这么写的代码：

void feed(Animal animal) {
    if (animal instanceof Elephant) {
        ((Elephant) animal).eatPlants();
    }
    else if (animal instanceof Tiger) {
        ((Tiger) animal).eatMeat();
    }
    
}

现在可以直接这么写：

void feed(Animal animal) {
    if (animal instanceof Elephant elephant)
        elephant.eatPlants();
    else if (animal instanceof Tiger tiger)
        tiger.eatMeat();
}

不需要空指针判断，因为 instanceof 已经自带 null 判断了，符合条件的 Type Pattern Matching 变量不会为 null。并且， Type Pattern Matching 不支持向上匹配，因为这个没有意义，即下面的代码会编译报错：

public void upcast(String string) {
    // compile error
    if (string instanceof CharSequence sequence)
        System.out.println("Duh");
}

还有一个常用的地方即实现 equals：

// old
@Override
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (!(o instanceof Equals))
        return false;
    Type other = (Type) o;
    return someField.equals(other.someField)
        && anotherField.equals(other.anotherField);
}

// new
@Override
public final boolean equals(Object o) {
    return o instanceof Type other
        && someField.equals(other.someField)
        && anotherField.equals(other.anotherField);
}

其实 Type Pattern Matching 是个语法糖

其实这个特性是一个语法糖，我们可以简单测试下：

public class TypePatternMatching {
    public static void main(String[] args) {
        Object object = new Object();
        if (object instanceof String s) {
            System.out.println("a");
        }
    }
}

查看编译后的字节码：

public class test.TypePatternMatching {
  public test.TypePatternMatching();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Object
       3: dup
       4: invokespecial #1                  // Method java/lang/Object."":()V
       7: astore_1
       8: aload_1
       9: instanceof    #7                  // class java/lang/String
      12: ifeq          28
      15: aload_1
      16: checkcast     #7                  // class java/lang/String
      19: astore_2
      20: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      23: ldc           #15                 // String a
      25: invokevirtual #17                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return
}

可以看出，字节码其实和下面的写法是一样的：

public static void main(String[] args) {
    Object object = new Object();
    if (object instanceof String) {
        String s = (String)object;
        System.out.println("a");
    }

}

大家可以反编译下这个 class，就能看出来。

Java 16 – Sealed Classes - Preview

Sealed Class 在 Java 17 已经发布了，相关的 JEP 如下：

• JEP 360: Sealed Classes (Preview)
• JEP 397: Sealed Classes (Second Preview)
• JEP 409: Sealed Classes

在某些情况下，我们可能想枚举一个接口的所有实现类，例如：

interface Shape { }
record Circle(double radius) implements Shape { }
record Rectangle(double width, double height) implements Shape { }

double area(Shape shape) {
    if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    throw new IllegalArgumentException("Unknown shape");
}

我们如何能确定我们枚举完了所有的 Shape 呢？ Sealed Class 这个特性为我们解决这个问题，Sealed Class 可以在声明的时候就决定这个类可以被哪些类继承：

sealed interface Shape permits Rectangle, Circle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
double area(Shape shape) {
    if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    throw new IllegalArgumentException("Unknown shape");
}

Sealed Class （可以是 abstract class 或者 interface ）在声明时需要指定所有的实现类的名称。针对继承类，有如下限制：

• Sealed Class 的继承类必须和 Sealed Class 在同一个模块下，如果没有指定模块，就必须在同一个包下
• 每个继承类必须直接继承 Sealed Class，不能间接继承

• 每个继承类必须是下面三种之一：

  • final 的 class，Java Record 本身就是 final 的
  • sealed 的 class，可以进一步指定会被哪些子类实现
  • non-sealed 的 class，也是一种扩展，但是打破 Sealed Class 的限制，Sealed Class 不知道也不关心这种的继承类还会有哪些子类。

举个例子即：

sealed interface Shape permits Rectangle, Circle, Triangle, WeirdShape {}
    
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}


sealed interface Triangle extends Shape permits RightTriangle, NormalTriangle {}
record RightTriangle(double width, double height) implements Triangle {}
record NormalTriangle(double width, double height) implements Triangle {}

static non-sealed class WeirdShape implements Shape {}
class Star extends WeirdShape {}

double area(Shape shape) {
    if (shape instanceof Circle circle)
        return circle.radius() * circle.radius() * Math.PI;
    if (shape instanceof Rectangle rect)
        return rect.width() * rect.height();
    if (shape instanceof RightTriangle rt)
        return rt.width() * rt.height() / 2;
    if (shape instanceof NormalTriangle nt)
        return nt.width() * nt.height() / 2;
    throw new IllegalArgumentException("Unknown shape");

}

如果结合 Pattern Matching for switch 这个特性，就能实现更加方便的写法，但是目前 Java 17 中，Pattern Matching for switch 还处于 Preview：JEP 406: Pattern Matching for switch (Preview)。我们需要在编译参数和启动参数中加上 --enable-preview，这样就能像下面这样写代码：

double area(Shape shape) {
    return switch (shape) {
        case Circle circle -> circle.radius() * circle.radius() * Math.PI;
        case Rectangle rect -> rect.width() * rect.height();
        case RightTriangle rt -> rt.width() * rt.height() / 2;
        case NormalTriangle nt -> nt.width( ) * nt.height() / 2;
        default -> throw new IllegalArgumentException("Unknown shape");
    };

}

Java 16 – Stream API 更新

Java 16 中针对 Stream API 有两个更新，这里先提一个题外话，如果想看 JDK 不同版本之间有何差异，增加或者删除了哪些 API，可以通过下面这个链接查看：

• https://javaalmanac.io/jdk/17...

路径中的两个版本就是要对比的两个版本，其界面如下：

同时，我们也可以通过 JDK 内置 jdeps 工具查找过期以及废弃API以及对应的替换

jdeps --jdk-internals -R --class-path 'libs/*' $project

libs是你的所有依赖的目录，$project是你的项目jar包，示例输出：

...
JDK Internal API                         Suggested Replacement
----------------                         ---------------------
sun.misc.BASE64Encoder                   Use java.util.Base64 @since 1.8
sun.reflect.Reflection                   Use java.lang.StackWalker @since 9

关于这个更新，我写了一篇文章进行解析：Java 16 中新增的 Stream 接口的一些思考，核心内容总结如下：

假设有邮件这个 Record 类，包含 id，以及发送到的邮箱和抄送到的邮箱：

record Mail(int id, Set sendTo, Set cc) {}

我们想找到一批邮件的所有不同的联系人，最后放到一个 List 中，可能会这么写：

Set collect = mails.stream().flatMap(mail -> {
    Set result = new HashSet<>();
    result.addAll(mail.sendTo());
    result.addAll(mail.cc());
    return result.stream();
}).collect(Collectors.toSet());

但是，这样写显然很不优雅，首先是对于每一个 Mail 都创建了额外的 Set 和对应的 Stream，并且，对于每个 mail 的 sendTo 还有 cc 都遍历了两遍（addAll 一遍，后续 Stream 又一遍）。其实我们的目前只是将 mail 中的 cc 以及 sendTo 取出来，用于参与后续的 Stream。在这种场景下，就非常适合用 mapMulti：

Set collect = mails.stream().mapMulti((mail, consumer) -> {
    mail.cc().forEach(consumer::accept);
    mail.sendTo().forEach(consumer::accept);
}).collect(Collectors.toSet());

可以看出：

• mapMulti 的入参是一个 BiConsumer，其实就是使用其参数中的 consumer 接收参与 Stream 后续的对象
• mapMulti 的思路就是将参数中的需要参与后续 Stream 的对象传入 consumer 来继续 Stream
• consumer 没有限制对象类型，想要限制必须加上形参 否则最后返回的是 Set