[{"data":1,"prerenderedAt":2126},["ShallowReactive",2],{"blog-\u002Fblog\u002Fjava-record-patterns":3},{"id":4,"title":5,"body":6,"description":2112,"difficulty":2113,"extension":2114,"framework":2115,"frameworkSlug":38,"meta":2116,"navigation":84,"order":171,"path":2117,"qaPath":2118,"seo":2119,"stem":2120,"subtopic":2121,"topic":2122,"topicSlug":2123,"updated":2124,"__hash__":2125},"blog\u002Fblog\u002Fjava-record-patterns.md","Java Record Patterns — Inline Deconstruction for Cleaner Switch Dispatch",{"type":7,"value":8,"toc":2100},"minimark",[9,14,30,33,175,178,230,247,251,258,493,503,507,510,814,817,997,1001,1007,1162,1168,1172,1178,1351,1357,1361,1368,1394,1531,1535,1542,1678,1682,1685,1918,1942,1946,1952,1963,1968,1979,2055,2059,2096],[10,11,13],"h2",{"id":12},"what-record-patterns-add-to-pattern-matching","What record patterns add to pattern matching",[15,16,17,21,22,25,26,29],"p",{},[18,19,20],"strong",{},"Record patterns"," (finalized in ",[18,23,24],{},"Java 21",", JEP 440) extend Java's pattern matching\nto allow ",[18,27,28],{},"inline deconstruction"," of record components. Instead of testing a type,\ncasting, and then calling accessors, you state the shape of the data you expect and bind\neach component to a variable in one expression.",[15,31,32],{},"Before record patterns:",[34,35,40],"pre",{"className":36,"code":37,"language":38,"meta":39,"style":39},"language-java shiki shiki-themes github-light github-dark","Object obj = new Point(3, 4);\n\nif (obj instanceof Point p) {\n    int x = p.x(); \u002F\u002F accessor\n    int y = p.y(); \u002F\u002F accessor\n    System.out.println(x + \", \" + y);\n}\n","java","",[41,42,43,79,86,101,125,144,169],"code",{"__ignoreMap":39},[44,45,48,52,56,59,63,66,70,73,76],"span",{"class":46,"line":47},"line",1,[44,49,51],{"class":50},"sVt8B","Object obj ",[44,53,55],{"class":54},"szBVR","=",[44,57,58],{"class":54}," new",[44,60,62],{"class":61},"sScJk"," Point",[44,64,65],{"class":50},"(",[44,67,69],{"class":68},"sj4cs","3",[44,71,72],{"class":50},", ",[44,74,75],{"class":68},"4",[44,77,78],{"class":50},");\n",[44,80,82],{"class":46,"line":81},2,[44,83,85],{"emptyLinePlaceholder":84},true,"\n",[44,87,89,92,95,98],{"class":46,"line":88},3,[44,90,91],{"class":54},"if",[44,93,94],{"class":50}," (obj ",[44,96,97],{"class":54},"instanceof",[44,99,100],{"class":50}," Point p) {\n",[44,102,104,107,110,112,115,118,121],{"class":46,"line":103},4,[44,105,106],{"class":54},"    int",[44,108,109],{"class":50}," x ",[44,111,55],{"class":54},[44,113,114],{"class":50}," p.",[44,116,117],{"class":61},"x",[44,119,120],{"class":50},"(); ",[44,122,124],{"class":123},"sJ8bj","\u002F\u002F accessor\n",[44,126,128,130,133,135,137,140,142],{"class":46,"line":127},5,[44,129,106],{"class":54},[44,131,132],{"class":50}," y ",[44,134,55],{"class":54},[44,136,114],{"class":50},[44,138,139],{"class":61},"y",[44,141,120],{"class":50},[44,143,124],{"class":123},[44,145,147,150,153,156,159,163,166],{"class":46,"line":146},6,[44,148,149],{"class":50},"    System.out.",[44,151,152],{"class":61},"println",[44,154,155],{"class":50},"(x ",[44,157,158],{"class":54},"+",[44,160,162],{"class":161},"sZZnC"," \", \"",[44,164,165],{"class":54}," +",[44,167,168],{"class":50}," y);\n",[44,170,172],{"class":46,"line":171},7,[44,173,174],{"class":50},"}\n",[15,176,177],{},"With record patterns (Java 21):",[34,179,181],{"className":36,"code":180,"language":38,"meta":39,"style":39},"if (obj instanceof Point(int x, int y)) {\n    System.out.println(x + \", \" + y); \u002F\u002F x and y bound directly\n}\n",[41,182,183,206,226],{"__ignoreMap":39},[44,184,185,187,189,191,193,195,198,201,203],{"class":46,"line":47},[44,186,91],{"class":54},[44,188,94],{"class":50},[44,190,97],{"class":54},[44,192,62],{"class":61},[44,194,65],{"class":50},[44,196,197],{"class":54},"int",[44,199,200],{"class":50}," x, ",[44,202,197],{"class":54},[44,204,205],{"class":50}," y)) {\n",[44,207,208,210,212,214,216,218,220,223],{"class":46,"line":81},[44,209,149],{"class":50},[44,211,152],{"class":61},[44,213,155],{"class":50},[44,215,158],{"class":54},[44,217,162],{"class":161},[44,219,165],{"class":54},[44,221,222],{"class":50}," y); ",[44,224,225],{"class":123},"\u002F\u002F x and y bound directly\n",[44,227,228],{"class":46,"line":88},[44,229,174],{"class":50},[15,231,232,233,236,237,240,241,243,244,246],{},"The type is checked and the components are destructured in a single expression. The\npattern ",[41,234,235],{},"Point(int x, int y)"," reads like a constructor call in reverse — \"match a\n",[41,238,239],{},"Point"," and extract its ",[41,242,117],{}," and ",[41,245,139],{},".\"",[10,248,250],{"id":249},"record-patterns-in-switch","Record patterns in switch",[15,252,253,254,257],{},"Record patterns are most powerful in ",[41,255,256],{},"switch"," expressions over sealed types:",[34,259,261],{"className":36,"code":260,"language":38,"meta":39,"style":39},"sealed interface Shape permits Circle, Rectangle, Triangle {}\nrecord Circle(double radius)          implements Shape {}\nrecord Rectangle(double w, double h)  implements Shape {}\nrecord Triangle(double base, double h) implements Shape {}\n\ndouble area(Shape s) {\n    return switch (s) {\n        case Circle(double r)              -> Math.PI * r * r;\n        case Rectangle(double w, double h) -> w * h;\n        case Triangle(double b, double h)  -> 0.5 * b * h;\n    };\n}\n",[41,262,263,293,315,340,365,369,379,390,422,449,482,488],{"__ignoreMap":39},[44,264,265,268,271,274,277,280,282,285,287,290],{"class":46,"line":47},[44,266,267],{"class":54},"sealed",[44,269,270],{"class":54}," interface",[44,272,273],{"class":61}," Shape",[44,275,276],{"class":54}," permits",[44,278,279],{"class":61}," Circle",[44,281,72],{"class":50},[44,283,284],{"class":61},"Rectangle",[44,286,72],{"class":50},[44,288,289],{"class":61},"Triangle",[44,291,292],{"class":50}," {}\n",[44,294,295,298,300,302,305,308,311,313],{"class":46,"line":81},[44,296,297],{"class":54},"record",[44,299,279],{"class":61},[44,301,65],{"class":50},[44,303,304],{"class":54},"double",[44,306,307],{"class":50}," radius)          ",[44,309,310],{"class":54},"implements",[44,312,273],{"class":61},[44,314,292],{"class":50},[44,316,317,319,322,324,326,329,331,334,336,338],{"class":46,"line":88},[44,318,297],{"class":54},[44,320,321],{"class":61}," Rectangle",[44,323,65],{"class":50},[44,325,304],{"class":54},[44,327,328],{"class":50}," w, ",[44,330,304],{"class":54},[44,332,333],{"class":50}," h)  ",[44,335,310],{"class":54},[44,337,273],{"class":61},[44,339,292],{"class":50},[44,341,342,344,347,349,351,354,356,359,361,363],{"class":46,"line":103},[44,343,297],{"class":54},[44,345,346],{"class":61}," Triangle",[44,348,65],{"class":50},[44,350,304],{"class":54},[44,352,353],{"class":50}," base, ",[44,355,304],{"class":54},[44,357,358],{"class":50}," h) ",[44,360,310],{"class":54},[44,362,273],{"class":61},[44,364,292],{"class":50},[44,366,367],{"class":46,"line":127},[44,368,85],{"emptyLinePlaceholder":84},[44,370,371,373,376],{"class":46,"line":146},[44,372,304],{"class":54},[44,374,375],{"class":61}," area",[44,377,378],{"class":50},"(Shape s) {\n",[44,380,381,384,387],{"class":46,"line":171},[44,382,383],{"class":54},"    return",[44,385,386],{"class":54}," switch",[44,388,389],{"class":50}," (s) {\n",[44,391,393,396,398,400,402,405,408,411,414,417,419],{"class":46,"line":392},8,[44,394,395],{"class":54},"        case",[44,397,279],{"class":61},[44,399,65],{"class":50},[44,401,304],{"class":54},[44,403,404],{"class":50}," r)              ",[44,406,407],{"class":54},"->",[44,409,410],{"class":50}," Math.PI ",[44,412,413],{"class":54},"*",[44,415,416],{"class":50}," r ",[44,418,413],{"class":54},[44,420,421],{"class":50}," r;\n",[44,423,425,427,429,431,433,435,437,439,441,444,446],{"class":46,"line":424},9,[44,426,395],{"class":54},[44,428,321],{"class":61},[44,430,65],{"class":50},[44,432,304],{"class":54},[44,434,328],{"class":50},[44,436,304],{"class":54},[44,438,358],{"class":50},[44,440,407],{"class":54},[44,442,443],{"class":50}," w ",[44,445,413],{"class":54},[44,447,448],{"class":50}," h;\n",[44,450,452,454,456,458,460,463,465,467,469,472,475,478,480],{"class":46,"line":451},10,[44,453,395],{"class":54},[44,455,346],{"class":61},[44,457,65],{"class":50},[44,459,304],{"class":54},[44,461,462],{"class":50}," b, ",[44,464,304],{"class":54},[44,466,333],{"class":50},[44,468,407],{"class":54},[44,470,471],{"class":68}," 0.5",[44,473,474],{"class":54}," *",[44,476,477],{"class":50}," b ",[44,479,413],{"class":54},[44,481,448],{"class":50},[44,483,485],{"class":46,"line":484},11,[44,486,487],{"class":50},"    };\n",[44,489,491],{"class":46,"line":490},12,[44,492,174],{"class":50},[15,494,495,496,499,500,502],{},"The compiler verifies exhaustiveness (all three ",[41,497,498],{},"Shape"," subtypes are covered), and the\ncomponents are bound inline — no ",[41,501,97],{}," checks, no casts, no accessor chains.",[10,504,506],{"id":505},"nested-record-patterns","Nested record patterns",[15,508,509],{},"Components that are themselves records can be destructured inline, eliminating deep\naccessor chains:",[34,511,513],{"className":36,"code":512,"language":38,"meta":39,"style":39},"record Point(int x, int y) {}\nrecord Line(Point start, Point end) {}\n\nObject obj = new Line(new Point(0, 0), new Point(3, 4));\n\n\u002F\u002F Accessor chain — verbose:\nif (obj instanceof Line l) {\n    int x1 = l.start().x(), y1 = l.start().y();\n    int x2 = l.end().x(),   y2 = l.end().y();\n}\n\n\u002F\u002F Nested record pattern — concise:\nif (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {\n    double length = Math.sqrt(Math.pow(x2-x1, 2) + Math.pow(y2-y1, 2));\n    System.out.println(\"length: \" + length); \u002F\u002F 5.0\n}\n",[41,514,515,532,542,546,590,594,599,610,646,679,683,687,692,733,789,809],{"__ignoreMap":39},[44,516,517,519,521,523,525,527,529],{"class":46,"line":47},[44,518,297],{"class":54},[44,520,62],{"class":61},[44,522,65],{"class":50},[44,524,197],{"class":54},[44,526,200],{"class":50},[44,528,197],{"class":54},[44,530,531],{"class":50}," y) {}\n",[44,533,534,536,539],{"class":46,"line":81},[44,535,297],{"class":54},[44,537,538],{"class":61}," Line",[44,540,541],{"class":50},"(Point start, Point end) {}\n",[44,543,544],{"class":46,"line":88},[44,545,85],{"emptyLinePlaceholder":84},[44,547,548,550,552,554,556,558,561,563,565,568,570,572,575,577,579,581,583,585,587],{"class":46,"line":103},[44,549,51],{"class":50},[44,551,55],{"class":54},[44,553,58],{"class":54},[44,555,538],{"class":61},[44,557,65],{"class":50},[44,559,560],{"class":54},"new",[44,562,62],{"class":61},[44,564,65],{"class":50},[44,566,567],{"class":68},"0",[44,569,72],{"class":50},[44,571,567],{"class":68},[44,573,574],{"class":50},"), ",[44,576,560],{"class":54},[44,578,62],{"class":61},[44,580,65],{"class":50},[44,582,69],{"class":68},[44,584,72],{"class":50},[44,586,75],{"class":68},[44,588,589],{"class":50},"));\n",[44,591,592],{"class":46,"line":127},[44,593,85],{"emptyLinePlaceholder":84},[44,595,596],{"class":46,"line":146},[44,597,598],{"class":123},"\u002F\u002F Accessor chain — verbose:\n",[44,600,601,603,605,607],{"class":46,"line":171},[44,602,91],{"class":54},[44,604,94],{"class":50},[44,606,97],{"class":54},[44,608,609],{"class":50}," Line l) {\n",[44,611,612,614,617,619,622,625,628,630,633,635,637,639,641,643],{"class":46,"line":392},[44,613,106],{"class":54},[44,615,616],{"class":50}," x1 ",[44,618,55],{"class":54},[44,620,621],{"class":50}," l.",[44,623,624],{"class":61},"start",[44,626,627],{"class":50},"().",[44,629,117],{"class":61},[44,631,632],{"class":50},"(), y1 ",[44,634,55],{"class":54},[44,636,621],{"class":50},[44,638,624],{"class":61},[44,640,627],{"class":50},[44,642,139],{"class":61},[44,644,645],{"class":50},"();\n",[44,647,648,650,653,655,657,660,662,664,667,669,671,673,675,677],{"class":46,"line":424},[44,649,106],{"class":54},[44,651,652],{"class":50}," x2 ",[44,654,55],{"class":54},[44,656,621],{"class":50},[44,658,659],{"class":61},"end",[44,661,627],{"class":50},[44,663,117],{"class":61},[44,665,666],{"class":50},"(),   y2 ",[44,668,55],{"class":54},[44,670,621],{"class":50},[44,672,659],{"class":61},[44,674,627],{"class":50},[44,676,139],{"class":61},[44,678,645],{"class":50},[44,680,681],{"class":46,"line":451},[44,682,174],{"class":50},[44,684,685],{"class":46,"line":484},[44,686,85],{"emptyLinePlaceholder":84},[44,688,689],{"class":46,"line":490},[44,690,691],{"class":123},"\u002F\u002F Nested record pattern — concise:\n",[44,693,695,697,699,701,703,705,707,709,711,714,716,719,721,723,725,728,730],{"class":46,"line":694},13,[44,696,91],{"class":54},[44,698,94],{"class":50},[44,700,97],{"class":54},[44,702,538],{"class":61},[44,704,65],{"class":50},[44,706,239],{"class":61},[44,708,65],{"class":50},[44,710,197],{"class":54},[44,712,713],{"class":50}," x1, ",[44,715,197],{"class":54},[44,717,718],{"class":50}," y1), ",[44,720,239],{"class":61},[44,722,65],{"class":50},[44,724,197],{"class":54},[44,726,727],{"class":50}," x2, ",[44,729,197],{"class":54},[44,731,732],{"class":50}," y2))) {\n",[44,734,736,739,742,744,747,750,753,756,759,762,765,768,771,773,775,777,780,782,785,787],{"class":46,"line":735},14,[44,737,738],{"class":54},"    double",[44,740,741],{"class":50}," length ",[44,743,55],{"class":54},[44,745,746],{"class":50}," Math.",[44,748,749],{"class":61},"sqrt",[44,751,752],{"class":50},"(Math.",[44,754,755],{"class":61},"pow",[44,757,758],{"class":50},"(x2",[44,760,761],{"class":54},"-",[44,763,764],{"class":50},"x1, ",[44,766,767],{"class":68},"2",[44,769,770],{"class":50},") ",[44,772,158],{"class":54},[44,774,746],{"class":50},[44,776,755],{"class":61},[44,778,779],{"class":50},"(y2",[44,781,761],{"class":54},[44,783,784],{"class":50},"y1, ",[44,786,767],{"class":68},[44,788,589],{"class":50},[44,790,792,794,796,798,801,803,806],{"class":46,"line":791},15,[44,793,149],{"class":50},[44,795,152],{"class":61},[44,797,65],{"class":50},[44,799,800],{"class":161},"\"length: \"",[44,802,165],{"class":54},[44,804,805],{"class":50}," length); ",[44,807,808],{"class":123},"\u002F\u002F 5.0\n",[44,810,812],{"class":46,"line":811},16,[44,813,174],{"class":50},[15,815,816],{},"Nesting is arbitrarily deep. This is especially clean for recursive data structures:",[34,818,820],{"className":36,"code":819,"language":38,"meta":39,"style":39},"sealed interface Expr permits Num, Add, Mul {}\nrecord Num(int v)           implements Expr {}\nrecord Add(Expr l, Expr r)  implements Expr {}\nrecord Mul(Expr l, Expr r)  implements Expr {}\n\nint eval(Expr e) {\n    return switch (e) {\n        case Num(int v)           -> v;\n        case Add(Expr l, Expr r)  -> eval(l) + eval(r);\n        case Mul(Expr l, Expr r)  -> eval(l) * eval(r);\n    };\n}\n\n\u002F\u002F eval(Mul(Num(2), Add(Num(3), Num(4)))) = 2 * (3 + 4) = 14\n",[41,821,822,848,867,883,898,902,912,921,938,960,980,984,988,992],{"__ignoreMap":39},[44,823,824,826,828,831,833,836,838,841,843,846],{"class":46,"line":47},[44,825,267],{"class":54},[44,827,270],{"class":54},[44,829,830],{"class":61}," Expr",[44,832,276],{"class":54},[44,834,835],{"class":61}," Num",[44,837,72],{"class":50},[44,839,840],{"class":61},"Add",[44,842,72],{"class":50},[44,844,845],{"class":61},"Mul",[44,847,292],{"class":50},[44,849,850,852,854,856,858,861,863,865],{"class":46,"line":81},[44,851,297],{"class":54},[44,853,835],{"class":61},[44,855,65],{"class":50},[44,857,197],{"class":54},[44,859,860],{"class":50}," v)           ",[44,862,310],{"class":54},[44,864,830],{"class":61},[44,866,292],{"class":50},[44,868,869,871,874,877,879,881],{"class":46,"line":88},[44,870,297],{"class":54},[44,872,873],{"class":61}," Add",[44,875,876],{"class":50},"(Expr l, Expr r)  ",[44,878,310],{"class":54},[44,880,830],{"class":61},[44,882,292],{"class":50},[44,884,885,887,890,892,894,896],{"class":46,"line":103},[44,886,297],{"class":54},[44,888,889],{"class":61}," Mul",[44,891,876],{"class":50},[44,893,310],{"class":54},[44,895,830],{"class":61},[44,897,292],{"class":50},[44,899,900],{"class":46,"line":127},[44,901,85],{"emptyLinePlaceholder":84},[44,903,904,906,909],{"class":46,"line":146},[44,905,197],{"class":54},[44,907,908],{"class":61}," eval",[44,910,911],{"class":50},"(Expr e) {\n",[44,913,914,916,918],{"class":46,"line":171},[44,915,383],{"class":54},[44,917,386],{"class":54},[44,919,920],{"class":50}," (e) {\n",[44,922,923,925,927,929,931,933,935],{"class":46,"line":392},[44,924,395],{"class":54},[44,926,835],{"class":61},[44,928,65],{"class":50},[44,930,197],{"class":54},[44,932,860],{"class":50},[44,934,407],{"class":54},[44,936,937],{"class":50}," v;\n",[44,939,940,942,944,946,948,950,953,955,957],{"class":46,"line":424},[44,941,395],{"class":54},[44,943,873],{"class":61},[44,945,876],{"class":50},[44,947,407],{"class":54},[44,949,908],{"class":61},[44,951,952],{"class":50},"(l) ",[44,954,158],{"class":54},[44,956,908],{"class":61},[44,958,959],{"class":50},"(r);\n",[44,961,962,964,966,968,970,972,974,976,978],{"class":46,"line":451},[44,963,395],{"class":54},[44,965,889],{"class":61},[44,967,876],{"class":50},[44,969,407],{"class":54},[44,971,908],{"class":61},[44,973,952],{"class":50},[44,975,413],{"class":54},[44,977,908],{"class":61},[44,979,959],{"class":50},[44,981,982],{"class":46,"line":484},[44,983,487],{"class":50},[44,985,986],{"class":46,"line":490},[44,987,174],{"class":50},[44,989,990],{"class":46,"line":694},[44,991,85],{"emptyLinePlaceholder":84},[44,993,994],{"class":46,"line":735},[44,995,996],{"class":123},"\u002F\u002F eval(Mul(Num(2), Add(Num(3), Num(4)))) = 2 * (3 + 4) = 14\n",[10,998,1000],{"id":999},"using-var-to-infer-component-types","Using var to infer component types",[15,1002,1003,1006],{},[41,1004,1005],{},"var"," can be used in a record pattern to let the compiler infer the component type:",[34,1008,1010],{"className":36,"code":1009,"language":38,"meta":39,"style":39},"record Pair\u003CA, B>(A first, B second) {}\n\nObject obj = new Pair\u003C>(\"hello\", 42);\n\nif (obj instanceof Pair(var first, var second)) {\n    System.out.println(first + \" \u002F \" + second);\n    \u002F\u002F first is Object (due to erasure), second is Object\n}\n\n\u002F\u002F If you know the concrete types:\nif (obj instanceof Pair(String first, Integer second)) {\n    System.out.println(first.toUpperCase() + \" \" + (second * 2));\n    \u002F\u002F compiler may warn: unchecked cast due to erasure\n}\n",[41,1011,1012,1028,1032,1053,1057,1071,1090,1095,1099,1103,1108,1121,1153,1158],{"__ignoreMap":39},[44,1013,1014,1017,1020,1022,1025],{"class":46,"line":47},[44,1015,1016],{"class":50},"record Pair\u003C",[44,1018,1019],{"class":54},"A",[44,1021,72],{"class":50},[44,1023,1024],{"class":54},"B",[44,1026,1027],{"class":50},">(A first, B second) {}\n",[44,1029,1030],{"class":46,"line":81},[44,1031,85],{"emptyLinePlaceholder":84},[44,1033,1034,1036,1038,1040,1043,1046,1048,1051],{"class":46,"line":88},[44,1035,51],{"class":50},[44,1037,55],{"class":54},[44,1039,58],{"class":54},[44,1041,1042],{"class":50}," Pair\u003C>(",[44,1044,1045],{"class":161},"\"hello\"",[44,1047,72],{"class":50},[44,1049,1050],{"class":68},"42",[44,1052,78],{"class":50},[44,1054,1055],{"class":46,"line":103},[44,1056,85],{"emptyLinePlaceholder":84},[44,1058,1059,1061,1063,1065,1068],{"class":46,"line":127},[44,1060,91],{"class":54},[44,1062,94],{"class":50},[44,1064,97],{"class":54},[44,1066,1067],{"class":61}," Pair",[44,1069,1070],{"class":50},"(var first, var second)) {\n",[44,1072,1073,1075,1077,1080,1082,1085,1087],{"class":46,"line":146},[44,1074,149],{"class":50},[44,1076,152],{"class":61},[44,1078,1079],{"class":50},"(first ",[44,1081,158],{"class":54},[44,1083,1084],{"class":161}," \" \u002F \"",[44,1086,165],{"class":54},[44,1088,1089],{"class":50}," second);\n",[44,1091,1092],{"class":46,"line":171},[44,1093,1094],{"class":123},"    \u002F\u002F first is Object (due to erasure), second is Object\n",[44,1096,1097],{"class":46,"line":392},[44,1098,174],{"class":50},[44,1100,1101],{"class":46,"line":424},[44,1102,85],{"emptyLinePlaceholder":84},[44,1104,1105],{"class":46,"line":451},[44,1106,1107],{"class":123},"\u002F\u002F If you know the concrete types:\n",[44,1109,1110,1112,1114,1116,1118],{"class":46,"line":484},[44,1111,91],{"class":54},[44,1113,94],{"class":50},[44,1115,97],{"class":54},[44,1117,1067],{"class":61},[44,1119,1120],{"class":50},"(String first, Integer second)) {\n",[44,1122,1123,1125,1127,1130,1133,1136,1138,1141,1143,1146,1148,1151],{"class":46,"line":490},[44,1124,149],{"class":50},[44,1126,152],{"class":61},[44,1128,1129],{"class":50},"(first.",[44,1131,1132],{"class":61},"toUpperCase",[44,1134,1135],{"class":50},"() ",[44,1137,158],{"class":54},[44,1139,1140],{"class":161}," \" \"",[44,1142,165],{"class":54},[44,1144,1145],{"class":50}," (second ",[44,1147,413],{"class":54},[44,1149,1150],{"class":68}," 2",[44,1152,589],{"class":50},[44,1154,1155],{"class":46,"line":694},[44,1156,1157],{"class":123},"    \u002F\u002F compiler may warn: unchecked cast due to erasure\n",[44,1159,1160],{"class":46,"line":735},[44,1161,174],{"class":50},[15,1163,1164,1165,1167],{},"For generic records, ",[41,1166,1005],{}," avoids unchecked warnings. Use explicit types only when\nyou're certain of the runtime types.",[10,1169,1171],{"id":1170},"guarded-patterns-when-clause","Guarded patterns — when clause",[15,1173,1174,1177],{},[41,1175,1176],{},"when"," guards attach a boolean condition to a record pattern:",[34,1179,1181],{"className":36,"code":1180,"language":38,"meta":39,"style":39},"String classify(Object obj) {\n    return switch (obj) {\n        case Point(int x, int y) when x == 0 && y == 0 -> \"origin\";\n        case Point(int x, int y) when x == 0            -> \"y-axis\";\n        case Point(int x, int y) when y == 0            -> \"x-axis\";\n        case Point(int x, int y)                        -> \"quadrant \" + quadrant(x, y);\n        default                                         -> \"not a point\";\n    };\n}\n",[41,1182,1183,1194,1203,1244,1272,1300,1330,1343,1347],{"__ignoreMap":39},[44,1184,1185,1188,1191],{"class":46,"line":47},[44,1186,1187],{"class":50},"String ",[44,1189,1190],{"class":61},"classify",[44,1192,1193],{"class":50},"(Object obj) {\n",[44,1195,1196,1198,1200],{"class":46,"line":81},[44,1197,383],{"class":54},[44,1199,386],{"class":54},[44,1201,1202],{"class":50}," (obj) {\n",[44,1204,1205,1207,1209,1211,1213,1215,1217,1220,1223,1226,1229,1231,1233,1235,1238,1241],{"class":46,"line":88},[44,1206,395],{"class":54},[44,1208,62],{"class":61},[44,1210,65],{"class":50},[44,1212,197],{"class":54},[44,1214,200],{"class":50},[44,1216,197],{"class":54},[44,1218,1219],{"class":50}," y) when x ",[44,1221,1222],{"class":54},"==",[44,1224,1225],{"class":68}," 0",[44,1227,1228],{"class":54}," &&",[44,1230,132],{"class":50},[44,1232,1222],{"class":54},[44,1234,1225],{"class":68},[44,1236,1237],{"class":54}," ->",[44,1239,1240],{"class":161}," \"origin\"",[44,1242,1243],{"class":50},";\n",[44,1245,1246,1248,1250,1252,1254,1256,1258,1260,1262,1264,1267,1270],{"class":46,"line":103},[44,1247,395],{"class":54},[44,1249,62],{"class":61},[44,1251,65],{"class":50},[44,1253,197],{"class":54},[44,1255,200],{"class":50},[44,1257,197],{"class":54},[44,1259,1219],{"class":50},[44,1261,1222],{"class":54},[44,1263,1225],{"class":68},[44,1265,1266],{"class":54},"            ->",[44,1268,1269],{"class":161}," \"y-axis\"",[44,1271,1243],{"class":50},[44,1273,1274,1276,1278,1280,1282,1284,1286,1289,1291,1293,1295,1298],{"class":46,"line":127},[44,1275,395],{"class":54},[44,1277,62],{"class":61},[44,1279,65],{"class":50},[44,1281,197],{"class":54},[44,1283,200],{"class":50},[44,1285,197],{"class":54},[44,1287,1288],{"class":50}," y) when y ",[44,1290,1222],{"class":54},[44,1292,1225],{"class":68},[44,1294,1266],{"class":54},[44,1296,1297],{"class":161}," \"x-axis\"",[44,1299,1243],{"class":50},[44,1301,1302,1304,1306,1308,1310,1312,1314,1317,1319,1322,1324,1327],{"class":46,"line":146},[44,1303,395],{"class":54},[44,1305,62],{"class":61},[44,1307,65],{"class":50},[44,1309,197],{"class":54},[44,1311,200],{"class":50},[44,1313,197],{"class":54},[44,1315,1316],{"class":50}," y)                        ",[44,1318,407],{"class":54},[44,1320,1321],{"class":161}," \"quadrant \"",[44,1323,165],{"class":54},[44,1325,1326],{"class":61}," quadrant",[44,1328,1329],{"class":50},"(x, y);\n",[44,1331,1332,1335,1338,1341],{"class":46,"line":171},[44,1333,1334],{"class":54},"        default",[44,1336,1337],{"class":54},"                                         ->",[44,1339,1340],{"class":161}," \"not a point\"",[44,1342,1243],{"class":50},[44,1344,1345],{"class":46,"line":392},[44,1346,487],{"class":50},[44,1348,1349],{"class":46,"line":424},[44,1350,174],{"class":50},[15,1352,1353,1354,1356],{},"Cases are evaluated top-to-bottom; the ",[41,1355,1176],{}," guard is checked only after the type and\nstructure match. More specific guards must come before more general ones.",[10,1358,1360],{"id":1359},"scope-and-null-behaviour","Scope and null behaviour",[15,1362,1363,1364,1367],{},"Variables bound in a record pattern follow the same ",[18,1365,1366],{},"flow-sensitive scope"," rules as\nall pattern variables:",[1369,1370,1371,1379,1385],"ul",{},[1372,1373,1374,1375,1378],"li",{},"In scope in the true branch and ",[41,1376,1377],{},"&&"," chains.",[1372,1380,1381,1382,1378],{},"Not in scope in the false\u002Felse branch or ",[41,1383,1384],{},"||",[1372,1386,1387,1390,1391,1393],{},[18,1388,1389],{},"Never bound for null"," — ",[41,1392,97],{}," returns false for null regardless of pattern.",[34,1395,1397],{"className":36,"code":1396,"language":38,"meta":39,"style":39},"Object obj = null;\nSystem.out.println(obj instanceof Point(int x, int y)); \u002F\u002F false — no NPE\n\n\u002F\u002F Handle null explicitly in switch:\nswitch (obj) {\n    case null                    -> System.out.println(\"null\");\n    case Point(int x, int y)     -> System.out.println(x + \", \" + y);\n    default                      -> System.out.println(\"other\");\n}\n",[41,1398,1399,1410,1438,1442,1447,1453,1475,1508,1527],{"__ignoreMap":39},[44,1400,1401,1403,1405,1408],{"class":46,"line":47},[44,1402,51],{"class":50},[44,1404,55],{"class":54},[44,1406,1407],{"class":68}," null",[44,1409,1243],{"class":50},[44,1411,1412,1415,1417,1420,1422,1424,1426,1428,1430,1432,1435],{"class":46,"line":81},[44,1413,1414],{"class":50},"System.out.",[44,1416,152],{"class":61},[44,1418,1419],{"class":50},"(obj ",[44,1421,97],{"class":54},[44,1423,62],{"class":61},[44,1425,65],{"class":50},[44,1427,197],{"class":54},[44,1429,200],{"class":50},[44,1431,197],{"class":54},[44,1433,1434],{"class":50}," y)); ",[44,1436,1437],{"class":123},"\u002F\u002F false — no NPE\n",[44,1439,1440],{"class":46,"line":88},[44,1441,85],{"emptyLinePlaceholder":84},[44,1443,1444],{"class":46,"line":103},[44,1445,1446],{"class":123},"\u002F\u002F Handle null explicitly in switch:\n",[44,1448,1449,1451],{"class":46,"line":127},[44,1450,256],{"class":54},[44,1452,1202],{"class":50},[44,1454,1455,1458,1460,1463,1466,1468,1470,1473],{"class":46,"line":146},[44,1456,1457],{"class":54},"    case",[44,1459,1407],{"class":68},[44,1461,1462],{"class":54},"                    ->",[44,1464,1465],{"class":50}," System.out.",[44,1467,152],{"class":61},[44,1469,65],{"class":50},[44,1471,1472],{"class":161},"\"null\"",[44,1474,78],{"class":50},[44,1476,1477,1479,1481,1483,1485,1487,1489,1492,1494,1496,1498,1500,1502,1504,1506],{"class":46,"line":171},[44,1478,1457],{"class":54},[44,1480,62],{"class":61},[44,1482,65],{"class":50},[44,1484,197],{"class":54},[44,1486,200],{"class":50},[44,1488,197],{"class":54},[44,1490,1491],{"class":50}," y)     ",[44,1493,407],{"class":54},[44,1495,1465],{"class":50},[44,1497,152],{"class":61},[44,1499,155],{"class":50},[44,1501,158],{"class":54},[44,1503,162],{"class":161},[44,1505,165],{"class":54},[44,1507,168],{"class":50},[44,1509,1510,1513,1516,1518,1520,1522,1525],{"class":46,"line":392},[44,1511,1512],{"class":54},"    default",[44,1514,1515],{"class":54},"                      ->",[44,1517,1465],{"class":50},[44,1519,152],{"class":61},[44,1521,65],{"class":50},[44,1523,1524],{"class":161},"\"other\"",[44,1526,78],{"class":50},[44,1528,1529],{"class":46,"line":424},[44,1530,174],{"class":50},[10,1532,1534],{"id":1533},"exhaustiveness-and-sealed-types","Exhaustiveness and sealed types",[15,1536,1537,1538,1541],{},"Exhaustiveness checking covers which ",[18,1539,1540],{},"subtypes"," are handled, not which component values.\nAdding a new subtype to a sealed interface breaks every exhaustive switch that doesn't\nhandle it — the compiler guides you to every site that needs updating:",[34,1543,1545],{"className":36,"code":1544,"language":38,"meta":39,"style":39},"sealed interface Event permits Login, Logout {}\nrecord Login(String userId, Instant at)  implements Event {}\nrecord Logout(String userId, Instant at) implements Event {}\n\nvoid audit(Event e) {\n    switch (e) {\n        case Login(String id, Instant t)  -> log(\"login\",  id, t);\n        case Logout(String id, Instant t) -> log(\"logout\", id, t);\n    }\n    \u002F\u002F Adding 'PasswordChange' to Event → compile error here\n}\n",[41,1546,1547,1568,1583,1599,1603,1614,1621,1643,1664,1669,1674],{"__ignoreMap":39},[44,1548,1549,1551,1553,1556,1558,1561,1563,1566],{"class":46,"line":47},[44,1550,267],{"class":54},[44,1552,270],{"class":54},[44,1554,1555],{"class":61}," Event",[44,1557,276],{"class":54},[44,1559,1560],{"class":61}," Login",[44,1562,72],{"class":50},[44,1564,1565],{"class":61},"Logout",[44,1567,292],{"class":50},[44,1569,1570,1572,1574,1577,1579,1581],{"class":46,"line":81},[44,1571,297],{"class":54},[44,1573,1560],{"class":61},[44,1575,1576],{"class":50},"(String userId, Instant at)  ",[44,1578,310],{"class":54},[44,1580,1555],{"class":61},[44,1582,292],{"class":50},[44,1584,1585,1587,1590,1593,1595,1597],{"class":46,"line":88},[44,1586,297],{"class":54},[44,1588,1589],{"class":61}," Logout",[44,1591,1592],{"class":50},"(String userId, Instant at) ",[44,1594,310],{"class":54},[44,1596,1555],{"class":61},[44,1598,292],{"class":50},[44,1600,1601],{"class":46,"line":103},[44,1602,85],{"emptyLinePlaceholder":84},[44,1604,1605,1608,1611],{"class":46,"line":127},[44,1606,1607],{"class":54},"void",[44,1609,1610],{"class":61}," audit",[44,1612,1613],{"class":50},"(Event e) {\n",[44,1615,1616,1619],{"class":46,"line":146},[44,1617,1618],{"class":54},"    switch",[44,1620,920],{"class":50},[44,1622,1623,1625,1627,1630,1632,1635,1637,1640],{"class":46,"line":171},[44,1624,395],{"class":54},[44,1626,1560],{"class":61},[44,1628,1629],{"class":50},"(String id, Instant t)  ",[44,1631,407],{"class":54},[44,1633,1634],{"class":61}," log",[44,1636,65],{"class":50},[44,1638,1639],{"class":161},"\"login\"",[44,1641,1642],{"class":50},",  id, t);\n",[44,1644,1645,1647,1649,1652,1654,1656,1658,1661],{"class":46,"line":392},[44,1646,395],{"class":54},[44,1648,1589],{"class":61},[44,1650,1651],{"class":50},"(String id, Instant t) ",[44,1653,407],{"class":54},[44,1655,1634],{"class":61},[44,1657,65],{"class":50},[44,1659,1660],{"class":161},"\"logout\"",[44,1662,1663],{"class":50},", id, t);\n",[44,1665,1666],{"class":46,"line":424},[44,1667,1668],{"class":50},"    }\n",[44,1670,1671],{"class":46,"line":451},[44,1672,1673],{"class":123},"    \u002F\u002F Adding 'PasswordChange' to Event → compile error here\n",[44,1675,1676],{"class":46,"line":484},[44,1677,174],{"class":50},[10,1679,1681],{"id":1680},"replacing-the-visitor-pattern","Replacing the Visitor pattern",[15,1683,1684],{},"Record patterns with sealed types are the idiomatic modern replacement for the Visitor\npattern. The Visitor existed to add operations on a closed type hierarchy without\nmodifying each class — sealed + switch achieves the same without the ceremony:",[34,1686,1688],{"className":36,"code":1687,"language":38,"meta":39,"style":39},"\u002F\u002F Visitor — requires: interface ExprVisitor\u003CR>, accept() in each Expr, ExprVisitorImpl\n\u002F\u002F ~60 lines for a 3-node tree\n\n\u002F\u002F Record patterns — zero infrastructure:\nint eval(Expr e) {\n    return switch (e) {\n        case Num(int v)           -> v;\n        case Add(Expr l, Expr r)  -> eval(l) + eval(r);\n        case Mul(Expr l, Expr r)  -> eval(l) * eval(r);\n    };\n}\n\nString prettyPrint(Expr e) {\n    return switch (e) {\n        case Num(int v)           -> String.valueOf(v);\n        case Add(Expr l, Expr r)  -> \"(\" + prettyPrint(l) + \" + \" + prettyPrint(r) + \")\";\n        case Mul(Expr l, Expr r)  -> \"(\" + prettyPrint(l) + \" × \" + prettyPrint(r) + \")\";\n    };\n}\n",[41,1689,1690,1695,1700,1704,1709,1717,1725,1741,1761,1781,1785,1789,1793,1802,1810,1833,1872,1908,1913],{"__ignoreMap":39},[44,1691,1692],{"class":46,"line":47},[44,1693,1694],{"class":123},"\u002F\u002F Visitor — requires: interface ExprVisitor\u003CR>, accept() in each Expr, ExprVisitorImpl\n",[44,1696,1697],{"class":46,"line":81},[44,1698,1699],{"class":123},"\u002F\u002F ~60 lines for a 3-node tree\n",[44,1701,1702],{"class":46,"line":88},[44,1703,85],{"emptyLinePlaceholder":84},[44,1705,1706],{"class":46,"line":103},[44,1707,1708],{"class":123},"\u002F\u002F Record patterns — zero infrastructure:\n",[44,1710,1711,1713,1715],{"class":46,"line":127},[44,1712,197],{"class":54},[44,1714,908],{"class":61},[44,1716,911],{"class":50},[44,1718,1719,1721,1723],{"class":46,"line":146},[44,1720,383],{"class":54},[44,1722,386],{"class":54},[44,1724,920],{"class":50},[44,1726,1727,1729,1731,1733,1735,1737,1739],{"class":46,"line":171},[44,1728,395],{"class":54},[44,1730,835],{"class":61},[44,1732,65],{"class":50},[44,1734,197],{"class":54},[44,1736,860],{"class":50},[44,1738,407],{"class":54},[44,1740,937],{"class":50},[44,1742,1743,1745,1747,1749,1751,1753,1755,1757,1759],{"class":46,"line":392},[44,1744,395],{"class":54},[44,1746,873],{"class":61},[44,1748,876],{"class":50},[44,1750,407],{"class":54},[44,1752,908],{"class":61},[44,1754,952],{"class":50},[44,1756,158],{"class":54},[44,1758,908],{"class":61},[44,1760,959],{"class":50},[44,1762,1763,1765,1767,1769,1771,1773,1775,1777,1779],{"class":46,"line":424},[44,1764,395],{"class":54},[44,1766,889],{"class":61},[44,1768,876],{"class":50},[44,1770,407],{"class":54},[44,1772,908],{"class":61},[44,1774,952],{"class":50},[44,1776,413],{"class":54},[44,1778,908],{"class":61},[44,1780,959],{"class":50},[44,1782,1783],{"class":46,"line":451},[44,1784,487],{"class":50},[44,1786,1787],{"class":46,"line":484},[44,1788,174],{"class":50},[44,1790,1791],{"class":46,"line":490},[44,1792,85],{"emptyLinePlaceholder":84},[44,1794,1795,1797,1800],{"class":46,"line":694},[44,1796,1187],{"class":50},[44,1798,1799],{"class":61},"prettyPrint",[44,1801,911],{"class":50},[44,1803,1804,1806,1808],{"class":46,"line":735},[44,1805,383],{"class":54},[44,1807,386],{"class":54},[44,1809,920],{"class":50},[44,1811,1812,1814,1816,1818,1820,1822,1824,1827,1830],{"class":46,"line":791},[44,1813,395],{"class":54},[44,1815,835],{"class":61},[44,1817,65],{"class":50},[44,1819,197],{"class":54},[44,1821,860],{"class":50},[44,1823,407],{"class":54},[44,1825,1826],{"class":50}," String.",[44,1828,1829],{"class":61},"valueOf",[44,1831,1832],{"class":50},"(v);\n",[44,1834,1835,1837,1839,1841,1843,1846,1848,1851,1853,1855,1858,1860,1862,1865,1867,1870],{"class":46,"line":811},[44,1836,395],{"class":54},[44,1838,873],{"class":61},[44,1840,876],{"class":50},[44,1842,407],{"class":54},[44,1844,1845],{"class":161}," \"(\"",[44,1847,165],{"class":54},[44,1849,1850],{"class":61}," prettyPrint",[44,1852,952],{"class":50},[44,1854,158],{"class":54},[44,1856,1857],{"class":161}," \" + \"",[44,1859,165],{"class":54},[44,1861,1850],{"class":61},[44,1863,1864],{"class":50},"(r) ",[44,1866,158],{"class":54},[44,1868,1869],{"class":161}," \")\"",[44,1871,1243],{"class":50},[44,1873,1875,1877,1879,1881,1883,1885,1887,1889,1891,1893,1896,1898,1900,1902,1904,1906],{"class":46,"line":1874},17,[44,1876,395],{"class":54},[44,1878,889],{"class":61},[44,1880,876],{"class":50},[44,1882,407],{"class":54},[44,1884,1845],{"class":161},[44,1886,165],{"class":54},[44,1888,1850],{"class":61},[44,1890,952],{"class":50},[44,1892,158],{"class":54},[44,1894,1895],{"class":161}," \" × \"",[44,1897,165],{"class":54},[44,1899,1850],{"class":61},[44,1901,1864],{"class":50},[44,1903,158],{"class":54},[44,1905,1869],{"class":161},[44,1907,1243],{"class":50},[44,1909,1911],{"class":46,"line":1910},18,[44,1912,487],{"class":50},[44,1914,1916],{"class":46,"line":1915},19,[44,1917,174],{"class":50},[15,1919,1920,1921,1924,1925,72,1928,72,1930,1933,1934,1937,1938,1941],{},"Adding a new ",[18,1922,1923],{},"operation"," (",[41,1926,1927],{},"eval",[41,1929,1799],{},[41,1931,1932],{},"typecheck",") means writing one new\nfunction. Adding a new ",[18,1935,1936],{},"type"," (e.g., ",[41,1939,1940],{},"Div",") breaks every existing switch — the compiler\ntells you exactly where to add the new case.",[10,1943,1945],{"id":1944},"when-to-use-record-patterns-vs-accessors","When to use record patterns vs accessors",[15,1947,1948,1951],{},[18,1949,1950],{},"Use a record pattern"," when:",[1369,1953,1954,1957,1960],{},[1372,1955,1956],{},"You need most or all components of a record.",[1372,1958,1959],{},"You're dispatching over multiple record types in a switch.",[1372,1961,1962],{},"Components are nested records and accessor chains would be verbose.",[15,1964,1965,1951],{},[18,1966,1967],{},"Use accessors",[1369,1969,1970,1973],{},[1372,1971,1972],{},"You only need one or two components of a large record.",[1372,1974,1975,1976,1978],{},"The binding variable name from the outer ",[41,1977,97],{}," is already clear.",[34,1980,1982],{"className":36,"code":1981,"language":38,"meta":39,"style":39},"\u002F\u002F Only need x — accessor is simpler:\nif (obj instanceof Point p) {\n    process(p.x());\n}\n\n\u002F\u002F Need both — record pattern wins:\nif (obj instanceof Point(int x, int y)) {\n    process(x, y);\n}\n",[41,1983,1984,1989,1999,2012,2016,2020,2025,2045,2051],{"__ignoreMap":39},[44,1985,1986],{"class":46,"line":47},[44,1987,1988],{"class":123},"\u002F\u002F Only need x — accessor is simpler:\n",[44,1990,1991,1993,1995,1997],{"class":46,"line":81},[44,1992,91],{"class":54},[44,1994,94],{"class":50},[44,1996,97],{"class":54},[44,1998,100],{"class":50},[44,2000,2001,2004,2007,2009],{"class":46,"line":88},[44,2002,2003],{"class":61},"    process",[44,2005,2006],{"class":50},"(p.",[44,2008,117],{"class":61},[44,2010,2011],{"class":50},"());\n",[44,2013,2014],{"class":46,"line":103},[44,2015,174],{"class":50},[44,2017,2018],{"class":46,"line":127},[44,2019,85],{"emptyLinePlaceholder":84},[44,2021,2022],{"class":46,"line":146},[44,2023,2024],{"class":123},"\u002F\u002F Need both — record pattern wins:\n",[44,2026,2027,2029,2031,2033,2035,2037,2039,2041,2043],{"class":46,"line":171},[44,2028,91],{"class":54},[44,2030,94],{"class":50},[44,2032,97],{"class":54},[44,2034,62],{"class":61},[44,2036,65],{"class":50},[44,2038,197],{"class":54},[44,2040,200],{"class":50},[44,2042,197],{"class":54},[44,2044,205],{"class":50},[44,2046,2047,2049],{"class":46,"line":392},[44,2048,2003],{"class":61},[44,2050,1329],{"class":50},[44,2052,2053],{"class":46,"line":424},[44,2054,174],{"class":50},[10,2056,2058],{"id":2057},"recap","Recap",[15,2060,2061,2063,2064,2066,2067,2069,2070,2073,2074,2078,2079,2084,2085,2088,2089,2091,2092,2095],{},[18,2062,20],{}," (Java 21) destructure record components inline in ",[41,2065,97],{}," and\n",[41,2068,256],{},", eliminating the accessor boilerplate when you need multiple values. They\nsupport ",[18,2071,2072],{},"nesting"," (components that are themselves records), ",[18,2075,2076],{},[41,2077,1005],{}," for type\ninference, and ",[18,2080,2081,2083],{},[41,2082,1176],{}," guards"," for component-level conditions. Null never matches a\nrecord pattern — handle it with ",[41,2086,2087],{},"case null"," in switch. Exhaustiveness checking in switch\ncovers which sealed subtypes are handled; component-value exhaustiveness uses ",[41,2090,1176],{}," plus\na catch-all case. Combined with ",[18,2093,2094],{},"sealed interfaces",", record patterns replace the\nVisitor pattern: adding a new operation is a new function; adding a new type variant\ncauses compile errors at every exhaustive switch that needs updating.",[2097,2098,2099],"style",{},"html pre.shiki code .sVt8B, html code.shiki .sVt8B{--shiki-default:#24292E;--shiki-dark:#E1E4E8}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":39,"searchDepth":81,"depth":81,"links":2101},[2102,2103,2104,2105,2106,2107,2108,2109,2110,2111],{"id":12,"depth":81,"text":13},{"id":249,"depth":81,"text":250},{"id":505,"depth":81,"text":506},{"id":999,"depth":81,"text":1000},{"id":1170,"depth":81,"text":1171},{"id":1359,"depth":81,"text":1360},{"id":1533,"depth":81,"text":1534},{"id":1680,"depth":81,"text":1681},{"id":1944,"depth":81,"text":1945},{"id":2057,"depth":81,"text":2058},"Complete guide to Java record patterns — destructuring record components in instanceof and switch, nested record patterns, var in patterns, guarded patterns, exhaustiveness, generics caveats, null handling, and replacing the Visitor pattern.","medium","md","Java",{},"\u002Fblog\u002Fjava-record-patterns","\u002Fjava\u002Fmodern-java\u002Frecord-patterns",{"title":5,"description":2112},"blog\u002Fjava-record-patterns","Record Patterns","Modern Java","modern-java","2026-06-20","PdlzsZM99mtn2MxtBEmiYzkiWnpVHHgxc6_86wFR4Rg",1782244091868]