1 摘要

通過使用記錄模式來增強Java編程語言，以解構(gòu)記錄值。記錄模式和類型模式可嵌套使用，從而實現(xiàn)強大、聲明式和可組合的數(shù)據(jù)導(dǎo)航和處理形式。

2 發(fā)展史

由 JEP 405 提出的預(yù)覽功能，并在JDK 19發(fā)布，然后由 JEP 432 再次預(yù)覽，并在JDK 20發(fā)布。該功能與用于switch的模式匹配（JEP 441）共同演進，并且二者有相當(dāng)大的交互作用。本JEP提議在持續(xù)的經(jīng)驗和反饋基礎(chǔ)上對該功能完善。

除了一些次要的編輯更改，自第二個預(yù)覽版以來的主要變化是刪除了對增強for語句頭部出現(xiàn)記錄模式的支持。這個功能可能會在未來的JEP中重提。

3 目標(biāo)

• 擴展模式匹配以解構(gòu)記錄類的實例，實現(xiàn)更復(fù)雜的數(shù)據(jù)查詢
• 添加嵌套模式，實現(xiàn)更可組合的數(shù)據(jù)查詢

4 動機

Java 16中， JEP 394 擴展了instanceof運算符，使其可接受類型模式并執(zhí)行模式匹配。這個簡單的擴展使得熟悉的instanceof和強制轉(zhuǎn)換慣用法變得更簡潔、更不易出錯：

// ＜Java 16
if (obj instanceof String) {
    String s = (String)obj;
    ... 使用s ...
}
// ≥Java 16
if (obj instanceof String s) {
    ... 使用s ...
}

新代碼中，若obj在運行時是String的實例，則obj與類型模式String s匹配。若模式匹配成功，則instanceof true，且模式變量s被初始化為obj強制轉(zhuǎn)換為String的值，然后可以在包含的代碼塊中使用。

類型模式一次性消除了許多類型轉(zhuǎn)換的出現(xiàn)。然而，它們只是朝著更聲明式、以數(shù)據(jù)為焦點的編程風(fēng)格邁出的第一步。隨Java支持新的、更具表現(xiàn)力的數(shù)據(jù)建模，模式匹配可通過讓開發(fā)表達模型的語義意圖來簡化對這些數(shù)據(jù)的使用。

5 Pattern matching和records

記錄 (JEP 395) 是數(shù)據(jù)的透明載體。接收記錄類實例的代碼通常會使用內(nèi)置的組件訪問器方法提取數(shù)據(jù)，即組件。

5.1 Point的實例

如用類型模式測試一個值是否是記錄類Point的實例，并在匹配成功時從該值中提取x和y組件。

Java8

class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public int getY() {
        return y;
    }
}
static void printSum(Object obj) {
    if (obj instanceof Point) {
        Point p = (Point) obj;
        int x = p.getX();
        int y = p.getY();
        System.out.println(x + y);
    }
}

≥Java 16

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

僅使用模式變量p調(diào)用訪問方法x()、y()，這些方法返回組件x和y的值。

在每個記錄類中，其訪問方法和組件之間存在一對一對應(yīng)關(guān)系。

如果模式不僅可測試一個值是否是Point的實例，還可直接從該值中提取x和y組件，從而代表我們調(diào)用訪問器方法的意圖將更好。換句話說：

// Java 21及以后
static void printSum(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println(x+y);
    }
}

Point(int x, int y) 是一個record pattern。它將用于提取組件的局部變量的聲明直接提升到模式本身，并在值與模式匹配時通過調(diào)用訪問方法對這些變量初始化。實際上，record pattern將記錄的實例解構(gòu)為其組件。

6 嵌套record pattern

模式匹配的真正威力在于優(yōu)雅擴展到匹配更復(fù)雜的對象圖。

考慮以下聲明：

// Java 16及以后
record Point(int x, int y) {}
enum Color { RED, GREEN, BLUE }
record ColoredPoint(Point p, Color c) {}
record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}

已知可使用記錄模式提取對象的組件。如想從左上角點提取顏色：

// Java 21及以后
static void printUpperLeftColoredPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
         System.out.println(ul.c());
    }
}

但ColoredPoint值ul本身是個記錄值，希望進一步分解。因此，記錄模式支持嵌套，允許對記錄組件進一步匹配、分解?？稍谟涗浤Ｊ街星短琢硪粋€模式，同時對外部和內(nèi)部記錄分解：

// Java 21及以后
static void printColorOfUpperLeftPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point p, Color c),
                               ColoredPoint lr)) {
        System.out.println(c);
    }
}

嵌套模式允許以與組裝對象的代碼一樣清晰簡潔方式拆解聚合。如創(chuàng)建一個矩形，通常會將構(gòu)造函數(shù)嵌套在一個表達式中：

// Java 16及以后
Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1), 
                            new ColoredPoint(new Point(x2, y2), c2));

使用嵌套模式，我們可以使用與嵌套構(gòu)造函數(shù)結(jié)構(gòu)相似的代碼來解構(gòu)這樣的矩形：

// Java 21及以后
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 21及以后
record Pair(Object x, Object y) {}
Pair p = new Pair(42, 42);
if (p instanceof Pair(String s, String t)) {
    System.out.println(s + ", " + t);
} else {
    System.out.println("Not a pair of strings");
}

這里的記錄模式Pair(String s, String t)包含了兩個嵌套的類型模式，即String s和String t。如果一個值與模式Pair(String s, String t)匹配，那么它是一個Pair，并且遞歸地，它的組件值與類型模式String s和String t匹配。在我們上面的示例代碼中，由于記錄的兩個組件值都不是字符串，因此這些遞歸的模式匹配失敗，因此執(zhí)行else塊。

總之，嵌套模式消除了導(dǎo)航對象的意外復(fù)雜性，使我們能專注這些對象所表示的數(shù)據(jù)。它們還賦予我們集中處理錯誤的能力，因為如果一個值無法與嵌套模式P(Q)匹配，那子模式P和Q中的任何一個或兩個都無法匹配。我們不需要檢查和處理每個單獨的子模式匹配失敗——要么整個模式匹配，要么不匹配。

7 描述

使用可嵌套的記錄模式。

模式語法變?yōu)椋?/p>

Pattern:
  TypePattern
  RecordPattern
TypePattern:
  LocalVariableDeclaration
RecordPattern:
  ReferenceType ( [ PatternList ] )
PatternList: 
  Pattern { , Pattern }

8 記錄模式

由記錄類類型和（可能為空的）模式列表組成，該列表用于與相應(yīng)的記錄組件值進行匹配。

如聲明

record Point(int i, int j) {}

如果值v與記錄模式Point(int i, int j)匹配，則它是記錄類型Point的實例；如這樣，模式變量i將被初始化為在值v上調(diào)用與i對應(yīng)的訪問器方法的結(jié)果，模式變量j將被初始化為在值v上調(diào)用與j對應(yīng)的訪問器方法的結(jié)果。（模式變量的名稱不需要與記錄組件的名稱相同；也就是說，記錄模式Point(int x, int y)的行為相同，只是模式變量x和y被初始化。）

null值不與任何記錄模式匹配。

記錄模式可用var來匹配記錄組件，而無需聲明組件的類型。在這種情況下，編譯器會推斷由var模式引入的模式變量的類型。如模式Point(var a, var b)是模式Point(int a, int b)的簡寫。

記錄模式聲明的模式變量集合包括模式列表中聲明的所有模式變量。

如果一個表達式可以在不需要未經(jīng)檢查的轉(zhuǎn)換的情況下將其轉(zhuǎn)換為模式中的記錄類型，則該表達式與記錄模式兼容。

如果記錄模式命名了一個泛型記錄類，但沒有給出類型參數(shù)（即，記錄模式使用原始類型），則始終會推斷類型參數(shù)。例如：

// Java 21及以后
record MyPair<S,T>(S fst, T snd){};
static void recordInference(MyPair<String, Integer> pair){
    switch (pair) {
        case MyPair(var f, var s) -> 
            ... // 推斷的記錄模式 MyPair<String,Integer>(var f, var s)
        ...
    }
}

記錄模式的類型參數(shù)推斷在支持記錄模式的所有結(jié)構(gòu)中都受到支持，即instanceof表達式和switch語句和表達式。

推斷適用于嵌套記錄模式；例如：

// Java 21及以后
record Box<T>(T t) {}
static void test1(Box<Box<String>> bbs) {
    if (bbs instanceof Box<Box<String>>(Box(var s))) {
        System.out.println("String " + s);
    }
}

這里，嵌套模式Box(var s)的類型參數(shù)被推斷為String，因此模式本身被推斷為Box(var s)。

甚至可省略外部記錄模式中的類型參數(shù)，得到簡潔代碼：

// Java 21及以后
static void test2(Box<Box<String>> bbs) {
    if (bbs instanceof Box(Box(var s))) {
        System.out.println("String " + s);
    }
}

這里編譯器會推斷整個instanceof模式為Box<Box<String>>(Box<String>(var s))。

為保持兼容性，類型模式不支持隱式推斷類型參數(shù)；如類型模式List l始終被視為原始類型模式。

9 記錄模式和完整的switch

JEP 441增強了switch表達式和switch語句，以支持模式標(biāo)簽。無論是switch表達式還是模式switch語句，都必須是完整的：switch塊必須有處理選擇器表達式的所有可能值的子句。對于模式標(biāo)簽，這是通過分析模式的類型來確定的；例如，case標(biāo)簽case Bar b匹配類型為Bar及其所有可能的子類型的值。

對于涉及記錄模式的模式標(biāo)簽，分析更加復(fù)雜，因為我們必須考慮組件模式的類型，并對密封層次結(jié)構(gòu)進行調(diào)整。例如，考慮以下聲明：

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的值的對：

// Java 21及以后
switch (p1) {                 // 錯誤！
    case Pair<A>(A a, B b) -> ...
    case Pair<A>(B b, A a) -> ...
}

這兩個switch是完整的，因為接口I是密封的，因此類型C和D涵蓋了所有可能的實例：

// Java 21及以后
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的值的對：

// Java 21及以后
switch (p2) {                        // 錯誤！
    case Pair<I>(C fst, D snd) -> ...
    case Pair<I>(D fst, C snd) -> ...
    case Pair<I>(I fst, C snd) -> ...
}

10 未來

記錄模式的描述中提到了許多可以擴展這里描述的記錄模式的方向：

• 可變參數(shù)模式，用于可變數(shù)量的記錄
• 匿名模式，可以出現(xiàn)在記錄模式的模式列表中，匹配任何值，但不聲明模式變量
• 適用于任意類的值而不僅僅是記錄類的模式。

我們可以在未來的JEP中考慮其中的一些方向。

11 依賴關(guān)系

本JEP建立在Pattern Matching for instanceof（JEP 394）的基礎(chǔ)上，該功能已在JDK 16中發(fā)布。它與Pattern Matching for switch（JEP 441）共同演進。

到此這篇關(guān)于JDK21新特性Record Patterns記錄模式詳解的文章就介紹到這了,更多相關(guān)JDK21新特性Record Patterns內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！