ToB企服应用市场:ToB评测及商务社交产业平台

标题: JDK21新特性Record Patterns记录模式详解 [打印本页]
作者: 缠丝猫    时间: 2023-10-3 23:13
标题: JDK21新特性Record Patterns记录模式详解
1 摘要

通过使用记录模式来增强Java编程语言，以解构记录值。记录模式和类型模式可嵌套使用，从而实现强大、声明式和可组合的数据导航和处理形式。
2 发展史

由 JEP 405 提出的预览功能，并在JDK 19发布，然后由 JEP 432 再次预览，并在JDK 20发布。该功能与用于switch的模式匹配（JEP 441）共同演进，并且二者有相当大的交互作用。本JEP提议在持续的经验和反馈基础上对该功能完善。
除了一些次要的编辑更改，自第二个预览版以来的主要变化是删除了对增强for语句头部出现记录模式的支持。这个功能可能会在未来的JEP中重提。
3 目标

4 动机

Java 16中， JEP 394 扩展了instanceof运算符，使其可接受类型模式并执行模式匹配。这个简单的扩展使得熟悉的instanceof和强制转换惯用法变得更简洁、更不易出错：
  1. // ＜Java 16
  2. if (obj instanceof String) {
  3.     String s = (String)obj;
  4.     ... 使用s ...
  5. }
  6. // ≥Java 16
  7. if (obj instanceof String s) {
  8.     ... 使用s ...
  9. }
复制代码
新代码中，若obj在运行时是String的实例，则obj与类型模式String s匹配。若模式匹配成功，则instanceof true，且模式变量s被初始化为obj强制转换为String的值，然后可以在包含的代码块中使用。
类型模式一次性消除了许多类型转换的出现。然而，它们只是朝着更声明式、以数据为焦点的编程风格迈出的第一步。随Java支持新的、更具表现力的数据建模，模式匹配可通过让开发表达模型的语义意图来简化对这些数据的使用。
5 Pattern matching和records

记录 (JEP 395) 是数据的透明载体。接收记录类实例的代码通常会使用内置的组件访问器方法提取数据，即组件。
5.1 Point的实例

如用类型模式测试一个值是否是记录类Point的实例，并在匹配成功时从该值中提取x和y组件。
Java8
  1. class Point {
  2.     private int x;
  3.     private int y;
  4.    
  5.     public Point(int x, int y) {
  6.         this.x = x;
  7.         this.y = y;
  8.     }
  9.    
  10.     public int getX() {
  11.         return x;
  12.     }
  13.    
  14.     public int getY() {
  15.         return y;
  16.     }
  17. }
  19. static void printSum(Object obj) {
  20.     if (obj instanceof Point) {
  21.         Point p = (Point) obj;
  22.         int x = p.getX();
  23.         int y = p.getY();
  24.         System.out.println(x + y);
  25.     }
  26. }
复制代码
≥Java 16
  1. record Point(int x, int y) {}
  3. static void printSum(Object obj) {
  4.     if (obj instanceof Point p) {
  5.         int x = p.x();
  6.         int y = p.y();
  7.         System.out.println(x+y);
  8.     }
  9. }
复制代码
仅使用模式变量p调用访问方法x()、y()，这些方法返回组件x和y的值。
在每个记录类中，其访问方法和组件之间存在一对一对应关系。
如果模式不仅可测试一个值是否是Point的实例，还可直接从该值中提取x和y组件，从而代表我们调用访问器方法的意图将更好。换句话说：
  1. // Java 21及以后
  2. static void printSum(Object obj) {
  3.     if (obj instanceof Point(int x, int y)) {
  4.         System.out.println(x+y);
  5.     }
  6. }
复制代码
Point(int x, int y) 是一个record pattern。它将用于提取组件的局部变量的声明直接提升到模式本身，并在值与模式匹配时通过调用访问方法对这些变量初始化。实际上，record pattern将记录的实例解构为其组件。
6 嵌套record pattern

模式匹配的真正威力在于优雅扩展到匹配更复杂的对象图。
考虑以下声明：
  1. // Java 16及以后
  2. record Point(int x, int y) {}
  3. enum Color { RED, GREEN, BLUE }
  4. record ColoredPoint(Point p, Color c) {}
  5. record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}
复制代码
已知可使用记录模式提取对象的组件。如想从左上角点提取颜色：
  1. // Java 21及以后
  2. static void printUpperLeftColoredPoint(Rectangle r) {
  3.     if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
  4.          System.out.println(ul.c());
  5.     }
  6. }
复制代码
但ColoredPoint值ul本身是个记录值，希望进一步分解。因此，记录模式支持嵌套，允许对记录组件进一步匹配、分解。可在记录模式中嵌套另一个模式，同时对外部和内部记录分解：
  1. // Java 21及以后
  2. static void printColorOfUpperLeftPoint(Rectangle r) {
  3.     if (r instanceof Rectangle(ColoredPoint(Point p, Color c),
  4.                                ColoredPoint lr)) {
  5.         System.out.println(c);
  6.     }
  7. }
复制代码
嵌套模式允许以与组装对象的代码一样清晰简洁方式拆解聚合。如创建一个矩形，通常会将构造函数嵌套在一个表达式中：
  1. // Java 16及以后
  2. Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1),
  3.                             new ColoredPoint(new Point(x2, y2), c2));
复制代码
使用嵌套模式，我们可以使用与嵌套构造函数结构相似的代码来解构这样的矩形：
  1. // Java 21及以后
  2. static void printXCoordOfUpperLeftPointWithPatterns(Rectangle r) {
  3.     if (r instanceof Rectangle(ColoredPoint(Point(var x, var y), var c),
  4.                                var lr)) {
  5.         System.out.println("Upper-left corner: " + x);
  6.     }
  7. }
复制代码
嵌套模式可能无法匹配：
  1. // Java 21及以后
  2. record Pair(Object x, Object y) {}
  3. Pair p = new Pair(42, 42);
  4. if (p instanceof Pair(String s, String t)) {
  5.     System.out.println(s + ", " + t);
  6. } else {
  7.     System.out.println("Not a pair of strings");
  8. }
复制代码
这里的记录模式Pair(String s, String t)包含了两个嵌套的类型模式，即String s和String t。如果一个值与模式Pair(String s, String t)匹配，那么它是一个Pair，并且递归地，它的组件值与类型模式String s和String t匹配。在我们上面的示例代码中，由于记录的两个组件值都不是字符串，因此这些递归的模式匹配失败，因此执行else块。
总之，嵌套模式消除了导航对象的意外复杂性，使我们能专注这些对象所表示的数据。它们还赋予我们集中处理错误的能力，因为如果一个值无法与嵌套模式P(Q)匹配，那子模式P和Q中的任何一个或两个都无法匹配。我们不需要检查和处理每个单独的子模式匹配失败——要么整个模式匹配，要么不匹配。
7 描述

使用可嵌套的记录模式。
模式语法变为：
  1. Pattern:
  2.   TypePattern
  3.   RecordPattern
  5. TypePattern:
  6.   LocalVariableDeclaration
  8. RecordPattern:
  9.   ReferenceType ( [ PatternList ] )
  11. PatternList:
  12.   Pattern { , Pattern }
复制代码
8 记录模式

由记录类类型和（可能为空的）模式列表组成，该列表用于与相应的记录组件值进行匹配。
如声明
  1. record Point(int i, int j) {}
复制代码
如果值v与记录模式Point(int i, int j)匹配，则它是记录类型Point的实例；如这样，模式变量i将被初始化为在值v上调用与i对应的访问器方法的结果，模式变量j将被初始化为在值v上调用与j对应的访问器方法的结果。（模式变量的名称不需要与记录组件的名称相同；也就是说，记录模式Point(int x, int y)的行为相同，只是模式变量x和y被初始化。）
null值不与任何记录模式匹配。
记录模式可用var来匹配记录组件，而无需声明组件的类型。在这种情况下，编译器会推断由var模式引入的模式变量的类型。如模式Point(var a, var b)是模式Point(int a, int b)的简写。
记录模式声明的模式变量集合包括模式列表中声明的所有模式变量。
如果一个表达式可以在不需要未经检查的转换的情况下将其转换为模式中的记录类型，则该表达式与记录模式兼容。
如果记录模式命名了一个泛型记录类，但没有给出类型参数（即，记录模式使用原始类型），则始终会推断类型参数。例如：
  1. // Java 21及以后
  2. record MyPair<S,T>(S fst, T snd){};
  3. static void recordInference(MyPair<String, Integer> pair){
  4.     switch (pair) {
  5.         case MyPair(var f, var s) ->
  6.             ... // 推断的记录模式 MyPair<String,Integer>(var f, var s)
  7.         ...
  8.     }
  9. }
复制代码
记录模式的类型参数推断在支持记录模式的所有结构中都受到支持，即instanceof表达式和switch语句和表达式。
推断适用于嵌套记录模式；例如：
  1. // Java 21及以后
  2. record Box<T>(T t) {}
  3. static void test1(Box<Box<String>> bbs) {
  4.     if (bbs instanceof Box<Box<String>>(Box(var s))) {
  5.         System.out.println("String " + s);
  6.     }
  7. }
复制代码
这里，嵌套模式Box(var s)的类型参数被推断为String，因此模式本身被推断为Box(var s)。
甚至可省略外部记录模式中的类型参数，得到简洁代码：
  1. // Java 21及以后
  2. static void test2(Box<Box<String>> bbs) {
  3.     if (bbs instanceof Box(Box(var s))) {
  4.         System.out.println("String " + s);
  5.     }
  6. }
复制代码
这里编译器会推断整个instanceof模式为Box(Box(var s))。
为保持兼容性，类型模式不支持隐式推断类型参数；如类型模式List l始终被视为原始类型模式。
9 记录模式和完整的switch

JEP 441增强了switch表达式和switch语句，以支持模式标签。无论是switch表达式还是模式switch语句，都必须是完整的：switch块必须有处理选择器表达式的所有可能值的子句。对于模式标签，这是通过分析模式的类型来确定的；例如，case标签case Bar b匹配类型为Bar及其所有可能的子类型的值。
对于涉及记录模式的模式标签，分析更加复杂，因为我们必须考虑组件模式的类型，并对密封层次结构进行调整。例如，考虑以下声明：
  1. class A {}
  2. class B extends A {}
  3. sealed interface I permits C, D {}
  4. final class C implements I {}
  5. final class D implements I {}
  6. record Pair<T>(T x, T y) {}
  7. Pair<A> p1;
  8. Pair<I> p2;
复制代码
以下switch不是完整的，因为没有匹配包含两个类型为A的值的对：
  1. // Java 21及以后
  2. switch (p1) {                 // 错误！
  3.     case Pair<A>(A a, B b) -> ...
  4.     case Pair<A>(B b, A a) -> ...
  5. }
复制代码
这两个switch是完整的，因为接口I是密封的，因此类型C和D涵盖了所有可能的实例：
  1. // Java 21及以后
  2. switch (p2) {
  3.     case Pair<I>(I i, C c) -> ...
  4.     case Pair<I>(I i, D d) -> ...
  5. }
  7. switch (p2) {
  8.     case Pair<I>(C c, I i) -> ...
  9.     case Pair<I>(D d, C c) -> ...
  10.     case Pair<I>(D d1, D d2) -> ...
  11. }
复制代码
相比之下，这个switch不是完整的，因为没有匹配包含两个类型为D的值的对：
  1. // Java 21及以后
  2. switch (p2) {                        // 错误！
  3.     case Pair<I>(C fst, D snd) -> ...
  4.     case Pair<I>(D fst, C snd) -> ...
  5.     case Pair<I>(I fst, C snd) -> ...
  6. }
复制代码
10 未来

记录模式的描述中提到了许多可以扩展这里描述的记录模式的方向：
我们可以在未来的JEP中考虑其中的一些方向。
11 依赖关系

本JEP建立在Pattern Matching for instanceof（JEP 394）的基础上，该功能已在JDK 16中发布。它与Pattern Matching for switch（JEP 441）共同演进。
本文由博客一文多发平台 OpenWrite 发布！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4