JEP 405：记录模式（预览）

QWen Max 中英对照 JEP 405 Record Patterns (Preview)

概述

通过 record 模式增强 Java 编程语言，以解构 record 值。Record 模式和类型模式可以嵌套使用，从而实现一种强大、声明性且可组合的数据导航与处理方式。这是一个预览语言功能。

目标

扩展模式匹配以表达更复杂、可组合的数据查询。
不要更改类型模式的语法或语义。

动机

在 JDK 16 中，JEP 394 扩展了 instanceof 运算符，使其能够接受一个 类型模式 并执行 模式匹配。这一适度的扩展简化了常见的 instanceof-然后-转换的习惯用法：

// Old code
if (o instanceof String) {
    String s = (String)o;
    ... use s ...
}

// New code
if (o instanceof String s) {
    ... use s ...
}

在新代码中，如果在运行时 o 的值是 String 的一个实例，则 o 匹配类型模式 String s。如果该模式匹配，那么 instanceof 表达式的结果为 true，并且模式变量 s 会被初始化为 o 转换为 String 类型后的值，然后可以在包含的代码块中使用该变量。

在 JDK 17 和 JDK 18 中，我们通过 JEP 406 和 JEP 420 将类型模式的使用扩展到了 switch 的 case 标签中。

类型模式一举消除了许多类型转换的出现。然而，它们只是朝着更声明式、数据聚焦的编程风格迈出的第一步。随着 Java 支持新的和更具表达力的数据建模方式，模式匹配可以通过使开发者表达其模型的语义意图来简化对此类数据的使用。

模式匹配与记录类

记录类（JEP 395）是数据的透明载体。接收记录类实例的代码通常会提取数据，这些数据被称为组成部分。例如，我们可以使用类型模式来测试某个值是否为记录类 Point 的实例，如果是，则从该值中提取 x 和 y 组成部分：

record Point(int x, int y) {}

static void printSum(Object o) {
    if (o instanceof Point p) {
        int x = p.x();
        int y = p.y();
        System.out.println(x+y);
    }
}

模式变量 p 在这里仅用于调用访问器方法 x() 和 y()，它们返回组件 x 和 y 的值。（在每个记录类中，其访问器方法和组件之间存在一一对应的关系。）如果该模式不仅能测试某个值是否是 Point 的实例，还能直接从该值中提取 x 和 y 组件，并自动为我们调用访问器方法，那就更好了。换句话说：

record Point(int x, int y) {}

void printSum(Object o) {
    if (o instanceof Point(int x, int y)) {
        System.out.println(x+y);
    }
}

Point(int x, int y) 是一个记录模式（record pattern）。它将提取组件的局部变量声明提升到模式本身中，并在值与模式匹配时通过调用访问器方法来初始化这些变量。实际上，记录模式将记录的实例分解为其组成部分。

模式匹配的真正强大之处在于，它可以优雅地扩展以匹配更复杂的对象图。例如，考虑以下声明：

record Point(int x, int y) {}
enum Color { RED, GREEN, BLUE }
record ColoredPoint(Point p, Color c) {}
record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}

我们已经看到，可以使用记录模式提取对象的组成部分。如果要从左上角的点提取颜色，可以这样写：

static void printUpperLeftColoredPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
         System.out.println(ul.c());
    }
}

但是我们的 ColoredPoint 本身就是一个记录，我们可能希望进一步对其进行分解。因此，记录模式支持嵌套，这允许记录组件通过嵌套模式进一步匹配并分解。我们可以在记录模式中嵌套另一个模式，从而一次性分解外部和内部的记录：

static void printColorOfUpperLeftPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point p, Color c),
                               ColoredPoint lr)) {
        System.out.println(c);
    }
}

嵌套模式使我们能够进一步使用清晰简洁的代码来分解一个聚合对象，就像我们用代码将其组合起来一样。例如，如果我们正在创建一个矩形，我们很可能会将构造函数嵌套在一个表达式中：

Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1), 
                            new ColoredPoint(new Point(x2, y2), c2));

通过嵌套模式，我们可以使用反映嵌套构造函数结构的代码来解构这样的矩形：

static void printXCoordOfUpperLeftPointWithPatterns(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point(var x, var y), var c),
                               var lr)) {
        System.out.println("Upper-left corner: " + x);
    }
}

总之，嵌套模式省略了导航对象的偶然复杂性，以便我们可以专注于这些对象所表达的数据。

描述

我们通过可嵌套的记录模式扩展了 Java 编程语言。

模式的语法将变为：

Pattern:
  TypePattern
  ParenthesizedPattern
  RecordPattern

TypePattern:
  LocalVariableDeclaration

ParenthesizedPattern:
  ( Pattern )

RecordPattern:
  ReferenceType RecordStructurePattern [ Identifier ]

RecordStructurePattern:
  ( [ RecordComponentPatternList ] )

RecordComponentPatternList : 
  Pattern { , Pattern }

记录模式

一个 记录模式 由一个类型、一个（可能为空的）记录组件模式列表（用于匹配相应的记录组件）以及一个可选的标识符组成。带有标识符的记录模式被称为 命名的 记录模式，该变量被称为 记录模式变量。

例如，给定声明

record Point(int i, int j) {}

一个值 v 匹配记录模式 Point(int i, int j) p 的条件是，它必须是记录类型 Point 的实例；如果是，则模式变量 i 会通过在值 v 上调用与 i 对应的访问器方法进行初始化，而模式变量 j 则通过在值 v 上调用与 j 对应的访问器方法进行初始化。（模式变量的名称不需要与记录组件的名称相同；例如，记录模式 Point(int x, int y) 的行为完全相同，只是模式变量 x 和 y 会被初始化。）记录模式变量 p 会被初始化为将 v 转换为 Point 类型后的值。

null 值与任何记录模式都不匹配。

记录模式可以使用 var 来匹配记录组件，而无需声明该组件的类型。在这种情况下，编译器会推断由 var 模式引入的模式变量的类型。例如，模式 Point(var a, var b) 是模式 Point(int a, int b) 的简写形式。

记录模式声明的模式变量集合包括记录组件模式列表中声明的所有模式变量，并且，如果记录模式是命名记录模式，则还包括记录模式变量。

如果某个表达式可以转换为模式中的记录类型，而无需进行未经检查的转换，则该表达式与记录模式兼容。

如果一个记录类是泛型的，那么任何命名该记录类的记录模式都必须使用泛型类型。例如，给出以下声明：

record Box<T>(T t) {}

以下方法是正确的：

static void test1(Box<Object> bo) {
    if (bo instanceof Box<Object>(String s)) {
        System.out.println("String " + s);
    }
}
static void test2(Box<Object> bo) {
    if (bo instanceof Box<String>(var s)) {
        System.out.println("String " + s);
    }
}

而下面两个示例都会导致编译时错误：

static void erroneousTest1(Box<Object> bo) {
    if (bo instanceof Box(var s)) {                 // Error
        System.out.println("I'm a box");
    }
}
static void erroneousTest2(Box b) {
    if (b instanceof Box(var t)) {                  // Error
        System.out.println("I'm a box");
    }
}

将来，我们可能会扩展推理以推断泛型记录模式的类型参数。

记录模式与穷尽性 `switch`

JEP 420 增强了 switch 表达式和 switch 语句，以支持包含模式的标签，包括记录模式。switch 表达式和模式 switch 语句都必须是详尽无遗的：switch 块必须包含处理选择器表达式所有可能值的子句。对于模式标签，这一点通过对模式类型的分析来确定；例如，case Bar b 的 case 标签匹配类型为 Bar 以及 Bar 所有可能的子类型的值。

涉及记录模式的模式标签的分析更为复杂，因为我们需要考虑组件模式的类型，并为 sealed 层次结构做出调整。例如，考虑以下声明：

class A {}
class B extends A {}
sealed interface I permits C, D {}
final class C implements I {}
final class D implements I {}
record Pair<T>(T x, T y) {}

Pair<A> p1;
Pair<I> p2;

以下 switch 并非详尽无遗，因为其中没有匹配包含两个均为类型 A 的值的对：

switch (p1) {                 // Error!
    case Pair<A>(A a, B b) -> ...
    case Pair<A>(B b, A a) -> ...
}

这两个开关是详尽无遗的，因为接口 I 是 sealed（密封）的，所以类型 C 和 D 涵盖了所有可能的实例：

switch (p2) {
    case Pair<I>(I i, C c) -> ...
    case Pair<I>(I i, D d) -> ...
}

switch (p2) {
    case Pair<I>(C c, I i) -> ...
    case Pair<I>(D d, C c) -> ...
    case Pair<I>(D d1, D d2) -> ...
}

相比之下，这个 switch 并不是详尽无遗的，因为没有匹配包含两个类型均为 D 的值的配对：

switch (p2) {                        // Error!
    case Pair<I>(C fst, D snd) -> ...
    case Pair<I>(D fst, C snd) -> ...
    case Pair<I>(I fst, C snd) -> ...
}

未来工作

这里描述的记录模式可以扩展的方向有很多：

数组模式，其子模式匹配单个数组元素；
可变参数模式，当记录是可变参数记录时适用；
泛型记录模式中类型参数的推断，可能使用钻石形式 (<>)；
不关心模式，它可以作为记录组件模式列表中的一个元素出现，但不声明模式变量；以及
基于任意类的模式，而不仅仅是记录类。

我们可能会在未来的 JEP 中考虑其中的一些。

依赖

本 JEP 基于 JEP 394（instanceof 的模式匹配），该功能已在 JDK 16 中交付。

概述​

目标​

动机​

模式匹配与记录类​

描述​

记录模式​

记录模式与穷尽性 switch​

未来工作​

依赖​

概述

目标

动机

模式匹配与记录类

描述

记录模式

记录模式与穷尽性 `switch`

未来工作

依赖