[{"data":1,"prerenderedAt":2363},["ShallowReactive",2],{"blog-\u002Fblog\u002Fjava-sequenced-collections":3},{"id":4,"title":5,"body":6,"description":2349,"difficulty":2350,"extension":2351,"framework":2352,"frameworkSlug":23,"meta":2353,"navigation":103,"order":143,"path":2354,"qaPath":2355,"seo":2356,"stem":2357,"subtopic":2358,"topic":2359,"topicSlug":2360,"updated":2361,"__hash__":2362},"blog\u002Fblog\u002Fjava-sequenced-collections.md","Java Sequenced Collections — getFirst, getLast, and reversed() for Every Ordered Type",{"type":7,"value":8,"toc":2331},"minimark",[9,14,18,192,195,213,217,222,233,326,474,478,500,598,602,608,731,869,873,880,963,966,998,1027,1031,1040,1190,1196,1200,1210,1404,1408,1419,1472,1489,1493,1508,1582,1603,1607,1617,1801,1806,1810,1840,1902,1918,1922,2263,2267,2327],[10,11,13],"h2",{"id":12},"the-problem-no-uniform-firstlast-api","The problem: no uniform first\u002Flast API",[15,16,17],"p",{},"Before Java 21, every ordered collection type had its own non-uniform way to access the\nfirst or last element:",[19,20,25],"pre",{"className":21,"code":22,"language":23,"meta":24,"style":24},"language-java shiki shiki-themes github-light github-dark","\u002F\u002F List:\nString first = list.get(0);\nString last  = list.get(list.size() - 1);   \u002F\u002F verbose, off-by-one risk\n\n\u002F\u002F Deque (ArrayDeque):\nString first = deque.peekFirst();\nString last  = deque.peekLast();\n\n\u002F\u002F SortedSet (TreeSet):\nString first = sortedSet.first();\nString last  = sortedSet.last();\n\n\u002F\u002F No collection had a unified reverse-iteration API without mutations or ugly iterators\n","java","",[26,27,28,37,65,98,105,111,127,141,146,152,167,181,186],"code",{"__ignoreMap":24},[29,30,33],"span",{"class":31,"line":32},"line",1,[29,34,36],{"class":35},"sJ8bj","\u002F\u002F List:\n",[29,38,40,44,48,51,55,58,62],{"class":31,"line":39},2,[29,41,43],{"class":42},"sVt8B","String first ",[29,45,47],{"class":46},"szBVR","=",[29,49,50],{"class":42}," list.",[29,52,54],{"class":53},"sScJk","get",[29,56,57],{"class":42},"(",[29,59,61],{"class":60},"sj4cs","0",[29,63,64],{"class":42},");\n",[29,66,68,71,73,75,77,80,83,86,89,92,95],{"class":31,"line":67},3,[29,69,70],{"class":42},"String last  ",[29,72,47],{"class":46},[29,74,50],{"class":42},[29,76,54],{"class":53},[29,78,79],{"class":42},"(list.",[29,81,82],{"class":53},"size",[29,84,85],{"class":42},"() ",[29,87,88],{"class":46},"-",[29,90,91],{"class":60}," 1",[29,93,94],{"class":42},");   ",[29,96,97],{"class":35},"\u002F\u002F verbose, off-by-one risk\n",[29,99,101],{"class":31,"line":100},4,[29,102,104],{"emptyLinePlaceholder":103},true,"\n",[29,106,108],{"class":31,"line":107},5,[29,109,110],{"class":35},"\u002F\u002F Deque (ArrayDeque):\n",[29,112,114,116,118,121,124],{"class":31,"line":113},6,[29,115,43],{"class":42},[29,117,47],{"class":46},[29,119,120],{"class":42}," deque.",[29,122,123],{"class":53},"peekFirst",[29,125,126],{"class":42},"();\n",[29,128,130,132,134,136,139],{"class":31,"line":129},7,[29,131,70],{"class":42},[29,133,47],{"class":46},[29,135,120],{"class":42},[29,137,138],{"class":53},"peekLast",[29,140,126],{"class":42},[29,142,144],{"class":31,"line":143},8,[29,145,104],{"emptyLinePlaceholder":103},[29,147,149],{"class":31,"line":148},9,[29,150,151],{"class":35},"\u002F\u002F SortedSet (TreeSet):\n",[29,153,155,157,159,162,165],{"class":31,"line":154},10,[29,156,43],{"class":42},[29,158,47],{"class":46},[29,160,161],{"class":42}," sortedSet.",[29,163,164],{"class":53},"first",[29,166,126],{"class":42},[29,168,170,172,174,176,179],{"class":31,"line":169},11,[29,171,70],{"class":42},[29,173,47],{"class":46},[29,175,161],{"class":42},[29,177,178],{"class":53},"last",[29,180,126],{"class":42},[29,182,184],{"class":31,"line":183},12,[29,185,104],{"emptyLinePlaceholder":103},[29,187,189],{"class":31,"line":188},13,[29,190,191],{"class":35},"\u002F\u002F No collection had a unified reverse-iteration API without mutations or ugly iterators\n",[15,193,194],{},"This inconsistency forced every \"get the last element\" line to be written differently\ndepending on which collection type was in scope — a genuine source of bugs and cognitive\noverhead.",[15,196,197,201,202,205,206,205,209,212],{},[198,199,200],"strong",{},"Sequenced collections"," (Java 21, JEP 431) fix this with three new interfaces that\nprovide a uniform ",[26,203,204],{},"getFirst()"," \u002F ",[26,207,208],{},"getLast()",[26,210,211],{},"reversed()"," API retrofitted onto the\nexisting hierarchy.",[10,214,216],{"id":215},"the-three-new-interfaces","The three new interfaces",[218,219,221],"h3",{"id":220},"sequencedcollectione","SequencedCollection\u003CE>",[15,223,224,225,228,229,232],{},"Extends ",[26,226,227],{},"Collection\u003CE>",". Represents any collection with a ",[198,230,231],{},"defined encounter order"," and\nadds:",[234,235,236,249],"table",{},[237,238,239],"thead",{},[240,241,242,246],"tr",{},[243,244,245],"th",{},"Method",[243,247,248],{},"Behaviour",[250,251,252,266,277,287,297,307,317],"tbody",{},[240,253,254,259],{},[255,256,257],"td",{},[26,258,204],{},[255,260,261,262,265],{},"First element; ",[26,263,264],{},"NoSuchElementException"," if empty",[240,267,268,272],{},[255,269,270],{},[26,271,208],{},[255,273,274,275,265],{},"Last element; ",[26,276,264],{},[240,278,279,284],{},[255,280,281],{},[26,282,283],{},"addFirst(E)",[255,285,286],{},"Insert at beginning (optional — UOE for fixed-size)",[240,288,289,294],{},[255,290,291],{},[26,292,293],{},"addLast(E)",[255,295,296],{},"Insert at end (optional)",[240,298,299,304],{},[255,300,301],{},[26,302,303],{},"removeFirst()",[255,305,306],{},"Remove and return first (optional)",[240,308,309,314],{},[255,310,311],{},[26,312,313],{},"removeLast()",[255,315,316],{},"Remove and return last (optional)",[240,318,319,323],{},[255,320,321],{},[26,322,211],{},[255,324,325],{},"Live reversed-order view",[19,327,329],{"className":21,"code":328,"language":23,"meta":24,"style":24},"List\u003CString> list = new ArrayList\u003C>(List.of(\"a\", \"b\", \"c\"));\n\nlist.getFirst();    \u002F\u002F \"a\"\nlist.getLast();     \u002F\u002F \"c\"\n\nlist.addFirst(\"z\"); \u002F\u002F [\"z\", \"a\", \"b\", \"c\"]\nlist.addLast(\"x\");  \u002F\u002F [\"z\", \"a\", \"b\", \"c\", \"x\"]\n\nlist.removeFirst(); \u002F\u002F \"z\" — list is now [\"a\", \"b\", \"c\", \"x\"]\nlist.removeLast();  \u002F\u002F \"x\" — list is now [\"a\", \"b\", \"c\"]\n",[26,330,331,373,377,391,404,408,426,444,448,461],{"__ignoreMap":24},[29,332,333,336,339,342,344,347,350,353,355,359,362,365,367,370],{"class":31,"line":32},[29,334,335],{"class":42},"List\u003C",[29,337,338],{"class":46},"String",[29,340,341],{"class":42},"> list ",[29,343,47],{"class":46},[29,345,346],{"class":46}," new",[29,348,349],{"class":42}," ArrayList\u003C>(List.",[29,351,352],{"class":53},"of",[29,354,57],{"class":42},[29,356,358],{"class":357},"sZZnC","\"a\"",[29,360,361],{"class":42},", ",[29,363,364],{"class":357},"\"b\"",[29,366,361],{"class":42},[29,368,369],{"class":357},"\"c\"",[29,371,372],{"class":42},"));\n",[29,374,375],{"class":31,"line":39},[29,376,104],{"emptyLinePlaceholder":103},[29,378,379,382,385,388],{"class":31,"line":67},[29,380,381],{"class":42},"list.",[29,383,384],{"class":53},"getFirst",[29,386,387],{"class":42},"();    ",[29,389,390],{"class":35},"\u002F\u002F \"a\"\n",[29,392,393,395,398,401],{"class":31,"line":100},[29,394,381],{"class":42},[29,396,397],{"class":53},"getLast",[29,399,400],{"class":42},"();     ",[29,402,403],{"class":35},"\u002F\u002F \"c\"\n",[29,405,406],{"class":31,"line":107},[29,407,104],{"emptyLinePlaceholder":103},[29,409,410,412,415,417,420,423],{"class":31,"line":113},[29,411,381],{"class":42},[29,413,414],{"class":53},"addFirst",[29,416,57],{"class":42},[29,418,419],{"class":357},"\"z\"",[29,421,422],{"class":42},"); ",[29,424,425],{"class":35},"\u002F\u002F [\"z\", \"a\", \"b\", \"c\"]\n",[29,427,428,430,433,435,438,441],{"class":31,"line":129},[29,429,381],{"class":42},[29,431,432],{"class":53},"addLast",[29,434,57],{"class":42},[29,436,437],{"class":357},"\"x\"",[29,439,440],{"class":42},");  ",[29,442,443],{"class":35},"\u002F\u002F [\"z\", \"a\", \"b\", \"c\", \"x\"]\n",[29,445,446],{"class":31,"line":143},[29,447,104],{"emptyLinePlaceholder":103},[29,449,450,452,455,458],{"class":31,"line":148},[29,451,381],{"class":42},[29,453,454],{"class":53},"removeFirst",[29,456,457],{"class":42},"(); ",[29,459,460],{"class":35},"\u002F\u002F \"z\" — list is now [\"a\", \"b\", \"c\", \"x\"]\n",[29,462,463,465,468,471],{"class":31,"line":154},[29,464,381],{"class":42},[29,466,467],{"class":53},"removeLast",[29,469,470],{"class":42},"();  ",[29,472,473],{"class":35},"\u002F\u002F \"x\" — list is now [\"a\", \"b\", \"c\"]\n",[218,475,477],{"id":476},"sequencedsete","SequencedSet\u003CE>",[15,479,480,481,483,484,487,488,491,492,495,496,499],{},"Extends both ",[26,482,221],{}," and ",[26,485,486],{},"Set\u003CE>",". No new methods, but guarantees set\nsemantics (no duplicates) on an ordered collection. Implemented by ",[26,489,490],{},"LinkedHashSet"," and\n",[26,493,494],{},"TreeSet"," (via ",[26,497,498],{},"SortedSet",").",[19,501,503],{"className":21,"code":502,"language":23,"meta":24,"style":24},"SequencedSet\u003CString> set = new LinkedHashSet\u003C>(List.of(\"banana\", \"apple\", \"cherry\"));\nset.getFirst(); \u002F\u002F \"banana\" — insertion order\nset.getLast();  \u002F\u002F \"cherry\"\n\n\u002F\u002F Reversed view:\nset.reversed().forEach(System.out::println); \u002F\u002F cherry, apple, banana\n",[26,504,505,541,553,564,568,573],{"__ignoreMap":24},[29,506,507,510,512,515,517,519,522,524,526,529,531,534,536,539],{"class":31,"line":32},[29,508,509],{"class":42},"SequencedSet\u003C",[29,511,338],{"class":46},[29,513,514],{"class":42},"> set ",[29,516,47],{"class":46},[29,518,346],{"class":46},[29,520,521],{"class":42}," LinkedHashSet\u003C>(List.",[29,523,352],{"class":53},[29,525,57],{"class":42},[29,527,528],{"class":357},"\"banana\"",[29,530,361],{"class":42},[29,532,533],{"class":357},"\"apple\"",[29,535,361],{"class":42},[29,537,538],{"class":357},"\"cherry\"",[29,540,372],{"class":42},[29,542,543,546,548,550],{"class":31,"line":39},[29,544,545],{"class":42},"set.",[29,547,384],{"class":53},[29,549,457],{"class":42},[29,551,552],{"class":35},"\u002F\u002F \"banana\" — insertion order\n",[29,554,555,557,559,561],{"class":31,"line":67},[29,556,545],{"class":42},[29,558,397],{"class":53},[29,560,470],{"class":42},[29,562,563],{"class":35},"\u002F\u002F \"cherry\"\n",[29,565,566],{"class":31,"line":100},[29,567,104],{"emptyLinePlaceholder":103},[29,569,570],{"class":31,"line":107},[29,571,572],{"class":35},"\u002F\u002F Reversed view:\n",[29,574,575,577,580,583,586,589,592,595],{"class":31,"line":113},[29,576,545],{"class":42},[29,578,579],{"class":53},"reversed",[29,581,582],{"class":42},"().",[29,584,585],{"class":53},"forEach",[29,587,588],{"class":42},"(System.out",[29,590,591],{"class":46},"::",[29,593,594],{"class":42},"println); ",[29,596,597],{"class":35},"\u002F\u002F cherry, apple, banana\n",[218,599,601],{"id":600},"sequencedmapk-v","SequencedMap\u003CK, V>",[15,603,224,604,607],{},[26,605,606],{},"Map\u003CK,V>"," and adds:",[234,609,610,618],{},[237,611,612],{},[240,613,614,616],{},[243,615,245],{},[243,617,248],{},[250,619,620,634,646,656,666,676,686,695,707,719],{},[240,621,622,627],{},[255,623,624],{},[26,625,626],{},"firstEntry()",[255,628,629,630,633],{},"First ",[26,631,632],{},"Map.Entry"," (no removal)",[240,635,636,641],{},[255,637,638],{},[26,639,640],{},"lastEntry()",[255,642,643,644,633],{},"Last ",[26,645,632],{},[240,647,648,653],{},[255,649,650],{},[26,651,652],{},"pollFirstEntry()",[255,654,655],{},"Remove and return first entry",[240,657,658,663],{},[255,659,660],{},[26,661,662],{},"pollLastEntry()",[255,664,665],{},"Remove and return last entry",[240,667,668,673],{},[255,669,670],{},[26,671,672],{},"putFirst(K, V)",[255,674,675],{},"Insert\u002Fmove to front (optional)",[240,677,678,683],{},[255,679,680],{},[26,681,682],{},"putLast(K, V)",[255,684,685],{},"Insert\u002Fmove to back (optional)",[240,687,688,692],{},[255,689,690],{},[26,691,211],{},[255,693,694],{},"Live reversed map view",[240,696,697,702],{},[255,698,699],{},[26,700,701],{},"sequencedKeySet()",[255,703,704],{},[26,705,706],{},"SequencedSet\u003CK>",[240,708,709,714],{},[255,710,711],{},[26,712,713],{},"sequencedValues()",[255,715,716],{},[26,717,718],{},"SequencedCollection\u003CV>",[240,720,721,726],{},[255,722,723],{},[26,724,725],{},"sequencedEntrySet()",[255,727,728],{},[26,729,730],{},"SequencedSet\u003CMap.Entry\u003CK,V>>",[19,732,734],{"className":21,"code":733,"language":23,"meta":24,"style":24},"SequencedMap\u003CString, Integer> scores = new LinkedHashMap\u003C>();\nscores.put(\"Alice\", 90);\nscores.put(\"Bob\",   85);\nscores.put(\"Carol\", 95);\n\nscores.firstEntry(); \u002F\u002F Alice=90\nscores.lastEntry();  \u002F\u002F Carol=95\n\nscores.putFirst(\"Zara\", 100); \u002F\u002F Zara is now the first entry\n",[26,735,736,758,778,797,815,819,831,843,847],{"__ignoreMap":24},[29,737,738,741,743,745,748,751,753,755],{"class":31,"line":32},[29,739,740],{"class":42},"SequencedMap\u003C",[29,742,338],{"class":46},[29,744,361],{"class":42},[29,746,747],{"class":46},"Integer",[29,749,750],{"class":42},"> scores ",[29,752,47],{"class":46},[29,754,346],{"class":46},[29,756,757],{"class":42}," LinkedHashMap\u003C>();\n",[29,759,760,763,766,768,771,773,776],{"class":31,"line":39},[29,761,762],{"class":42},"scores.",[29,764,765],{"class":53},"put",[29,767,57],{"class":42},[29,769,770],{"class":357},"\"Alice\"",[29,772,361],{"class":42},[29,774,775],{"class":60},"90",[29,777,64],{"class":42},[29,779,780,782,784,786,789,792,795],{"class":31,"line":67},[29,781,762],{"class":42},[29,783,765],{"class":53},[29,785,57],{"class":42},[29,787,788],{"class":357},"\"Bob\"",[29,790,791],{"class":42},",   ",[29,793,794],{"class":60},"85",[29,796,64],{"class":42},[29,798,799,801,803,805,808,810,813],{"class":31,"line":100},[29,800,762],{"class":42},[29,802,765],{"class":53},[29,804,57],{"class":42},[29,806,807],{"class":357},"\"Carol\"",[29,809,361],{"class":42},[29,811,812],{"class":60},"95",[29,814,64],{"class":42},[29,816,817],{"class":31,"line":107},[29,818,104],{"emptyLinePlaceholder":103},[29,820,821,823,826,828],{"class":31,"line":113},[29,822,762],{"class":42},[29,824,825],{"class":53},"firstEntry",[29,827,457],{"class":42},[29,829,830],{"class":35},"\u002F\u002F Alice=90\n",[29,832,833,835,838,840],{"class":31,"line":129},[29,834,762],{"class":42},[29,836,837],{"class":53},"lastEntry",[29,839,470],{"class":42},[29,841,842],{"class":35},"\u002F\u002F Carol=95\n",[29,844,845],{"class":31,"line":143},[29,846,104],{"emptyLinePlaceholder":103},[29,848,849,851,854,856,859,861,864,866],{"class":31,"line":148},[29,850,762],{"class":42},[29,852,853],{"class":53},"putFirst",[29,855,57],{"class":42},[29,857,858],{"class":357},"\"Zara\"",[29,860,361],{"class":42},[29,862,863],{"class":60},"100",[29,865,422],{"class":42},[29,867,868],{"class":35},"\u002F\u002F Zara is now the first entry\n",[10,870,872],{"id":871},"which-existing-collections-implement-the-new-interfaces","Which existing collections implement the new interfaces",[15,874,875,876,879],{},"The new interfaces are retroactively wired into the existing collection hierarchy —\n",[198,877,878],{},"you don't need to change your existing code to get the methods",":",[234,881,882,892],{},[237,883,884],{},[240,885,886,889],{},[243,887,888],{},"Concrete type",[243,890,891],{},"Implements",[250,893,894,912,923,937,949],{},[240,895,896,907],{},[255,897,898,361,901,361,904],{},[26,899,900],{},"ArrayList",[26,902,903],{},"LinkedList",[26,905,906],{},"ArrayDeque",[255,908,909],{},[26,910,911],{},"SequencedCollection",[240,913,914,918],{},[255,915,916],{},[26,917,490],{},[255,919,920],{},[26,921,922],{},"SequencedSet",[240,924,925,929],{},[255,926,927],{},[26,928,494],{},[255,930,931,495,933,936],{},[26,932,922],{},[26,934,935],{},"SortedSet → SequencedSet",")",[240,938,939,944],{},[255,940,941],{},[26,942,943],{},"LinkedHashMap",[255,945,946],{},[26,947,948],{},"SequencedMap",[240,950,951,956],{},[255,952,953],{},[26,954,955],{},"TreeMap",[255,957,958,495,960,936],{},[26,959,948],{},[26,961,962],{},"SortedMap → SequencedMap",[15,964,965],{},"Interface hierarchy additions:",[967,968,969,978,985,991],"ul",{},[970,971,972,975,976],"li",{},[26,973,974],{},"List"," extends ",[26,977,911],{},[970,979,980,975,983],{},[26,981,982],{},"Deque",[26,984,911],{},[970,986,987,975,989],{},[26,988,498],{},[26,990,922],{},[970,992,993,975,996],{},[26,994,995],{},"SortedMap",[26,997,948],{},[15,999,1000,1001,361,1004,1007,1008,1011,1012,1014,1015,1017,1018,1020,1021,1023,1024,1026],{},"So ",[26,1002,1003],{},"List.of()",[26,1005,1006],{},"Collections.unmodifiableList()",", and ",[26,1009,1010],{},"Arrays.asList()"," all have\n",[26,1013,204],{},"\u002F",[26,1016,208],{}," now — they're ",[26,1019,974],{}," instances and ",[26,1022,974],{}," is a\n",[26,1025,911],{},".",[10,1028,1030],{"id":1029},"the-reversed-method-a-live-view","The reversed() method — a live view",[15,1032,1033,1035,1036,1039],{},[26,1034,211],{}," returns a ",[198,1037,1038],{},"live, write-through view"," of the collection in reverse order:",[19,1041,1043],{"className":21,"code":1042,"language":23,"meta":24,"style":24},"List\u003CInteger> list = new ArrayList\u003C>(List.of(1, 2, 3, 4, 5));\nList\u003CInteger> rev  = list.reversed();\n\nSystem.out.println(rev);    \u002F\u002F [5, 4, 3, 2, 1]\n\nlist.add(6);                \u002F\u002F mutate original\nSystem.out.println(rev);    \u002F\u002F [6, 5, 4, 3, 2, 1] — reflected in view\n\nrev.addFirst(99);           \u002F\u002F add to reversed view's front (= original's back)\nSystem.out.println(list);   \u002F\u002F [1, 2, 3, 4, 5, 6, 99]\n",[26,1044,1045,1088,1105,1109,1123,1127,1145,1156,1160,1178],{"__ignoreMap":24},[29,1046,1047,1049,1051,1053,1055,1057,1059,1061,1063,1066,1068,1071,1073,1076,1078,1081,1083,1086],{"class":31,"line":32},[29,1048,335],{"class":42},[29,1050,747],{"class":46},[29,1052,341],{"class":42},[29,1054,47],{"class":46},[29,1056,346],{"class":46},[29,1058,349],{"class":42},[29,1060,352],{"class":53},[29,1062,57],{"class":42},[29,1064,1065],{"class":60},"1",[29,1067,361],{"class":42},[29,1069,1070],{"class":60},"2",[29,1072,361],{"class":42},[29,1074,1075],{"class":60},"3",[29,1077,361],{"class":42},[29,1079,1080],{"class":60},"4",[29,1082,361],{"class":42},[29,1084,1085],{"class":60},"5",[29,1087,372],{"class":42},[29,1089,1090,1092,1094,1097,1099,1101,1103],{"class":31,"line":39},[29,1091,335],{"class":42},[29,1093,747],{"class":46},[29,1095,1096],{"class":42},"> rev  ",[29,1098,47],{"class":46},[29,1100,50],{"class":42},[29,1102,579],{"class":53},[29,1104,126],{"class":42},[29,1106,1107],{"class":31,"line":67},[29,1108,104],{"emptyLinePlaceholder":103},[29,1110,1111,1114,1117,1120],{"class":31,"line":100},[29,1112,1113],{"class":42},"System.out.",[29,1115,1116],{"class":53},"println",[29,1118,1119],{"class":42},"(rev);    ",[29,1121,1122],{"class":35},"\u002F\u002F [5, 4, 3, 2, 1]\n",[29,1124,1125],{"class":31,"line":107},[29,1126,104],{"emptyLinePlaceholder":103},[29,1128,1129,1131,1134,1136,1139,1142],{"class":31,"line":113},[29,1130,381],{"class":42},[29,1132,1133],{"class":53},"add",[29,1135,57],{"class":42},[29,1137,1138],{"class":60},"6",[29,1140,1141],{"class":42},");                ",[29,1143,1144],{"class":35},"\u002F\u002F mutate original\n",[29,1146,1147,1149,1151,1153],{"class":31,"line":129},[29,1148,1113],{"class":42},[29,1150,1116],{"class":53},[29,1152,1119],{"class":42},[29,1154,1155],{"class":35},"\u002F\u002F [6, 5, 4, 3, 2, 1] — reflected in view\n",[29,1157,1158],{"class":31,"line":143},[29,1159,104],{"emptyLinePlaceholder":103},[29,1161,1162,1165,1167,1169,1172,1175],{"class":31,"line":148},[29,1163,1164],{"class":42},"rev.",[29,1166,414],{"class":53},[29,1168,57],{"class":42},[29,1170,1171],{"class":60},"99",[29,1173,1174],{"class":42},");           ",[29,1176,1177],{"class":35},"\u002F\u002F add to reversed view's front (= original's back)\n",[29,1179,1180,1182,1184,1187],{"class":31,"line":154},[29,1181,1113],{"class":42},[29,1183,1116],{"class":53},[29,1185,1186],{"class":42},"(list);   ",[29,1188,1189],{"class":35},"\u002F\u002F [1, 2, 3, 4, 5, 6, 99]\n",[15,1191,1192,1193,1026],{},"Because it's a live view, mutations through either handle affect both. If you need an\nindependent reversed copy, call ",[26,1194,1195],{},"new ArrayList\u003C>(list.reversed())",[218,1197,1199],{"id":1198},"practical-use-iterating-in-reverse-without-mutations","Practical use — iterating in reverse without mutations",[15,1201,1202,1203,1206,1207,879],{},"Before Java 21, reversing iteration required either mutating the list (",[26,1204,1205],{},"Collections.reverse()",")\nor using a backwards ",[26,1208,1209],{},"ListIterator",[19,1211,1213],{"className":21,"code":1212,"language":23,"meta":24,"style":24},"\u002F\u002F Old — mutates the list:\nCollections.reverse(list);\nlist.forEach(System.out::println);\nCollections.reverse(list); \u002F\u002F put it back\n\n\u002F\u002F Old — verbose iterator:\nvar it = list.listIterator(list.size());\nwhile (it.hasPrevious()) System.out.println(it.previous());\n\n\u002F\u002F Java 21 — clean:\nlist.reversed().forEach(System.out::println);  \u002F\u002F no mutation\n\n\u002F\u002F Or with streams:\nlist.reversed().stream()\n    .filter(x -> x > 2)\n    .forEach(System.out::println);\n",[26,1214,1215,1220,1231,1244,1256,1260,1265,1287,1311,1315,1320,1340,1344,1349,1364,1391],{"__ignoreMap":24},[29,1216,1217],{"class":31,"line":32},[29,1218,1219],{"class":35},"\u002F\u002F Old — mutates the list:\n",[29,1221,1222,1225,1228],{"class":31,"line":39},[29,1223,1224],{"class":42},"Collections.",[29,1226,1227],{"class":53},"reverse",[29,1229,1230],{"class":42},"(list);\n",[29,1232,1233,1235,1237,1239,1241],{"class":31,"line":67},[29,1234,381],{"class":42},[29,1236,585],{"class":53},[29,1238,588],{"class":42},[29,1240,591],{"class":46},[29,1242,1243],{"class":42},"println);\n",[29,1245,1246,1248,1250,1253],{"class":31,"line":100},[29,1247,1224],{"class":42},[29,1249,1227],{"class":53},[29,1251,1252],{"class":42},"(list); ",[29,1254,1255],{"class":35},"\u002F\u002F put it back\n",[29,1257,1258],{"class":31,"line":107},[29,1259,104],{"emptyLinePlaceholder":103},[29,1261,1262],{"class":31,"line":113},[29,1263,1264],{"class":35},"\u002F\u002F Old — verbose iterator:\n",[29,1266,1267,1270,1273,1275,1277,1280,1282,1284],{"class":31,"line":129},[29,1268,1269],{"class":46},"var",[29,1271,1272],{"class":42}," it ",[29,1274,47],{"class":46},[29,1276,50],{"class":42},[29,1278,1279],{"class":53},"listIterator",[29,1281,79],{"class":42},[29,1283,82],{"class":53},[29,1285,1286],{"class":42},"());\n",[29,1288,1289,1292,1295,1298,1301,1303,1306,1309],{"class":31,"line":143},[29,1290,1291],{"class":46},"while",[29,1293,1294],{"class":42}," (it.",[29,1296,1297],{"class":53},"hasPrevious",[29,1299,1300],{"class":42},"()) System.out.",[29,1302,1116],{"class":53},[29,1304,1305],{"class":42},"(it.",[29,1307,1308],{"class":53},"previous",[29,1310,1286],{"class":42},[29,1312,1313],{"class":31,"line":148},[29,1314,104],{"emptyLinePlaceholder":103},[29,1316,1317],{"class":31,"line":154},[29,1318,1319],{"class":35},"\u002F\u002F Java 21 — clean:\n",[29,1321,1322,1324,1326,1328,1330,1332,1334,1337],{"class":31,"line":169},[29,1323,381],{"class":42},[29,1325,579],{"class":53},[29,1327,582],{"class":42},[29,1329,585],{"class":53},[29,1331,588],{"class":42},[29,1333,591],{"class":46},[29,1335,1336],{"class":42},"println);  ",[29,1338,1339],{"class":35},"\u002F\u002F no mutation\n",[29,1341,1342],{"class":31,"line":183},[29,1343,104],{"emptyLinePlaceholder":103},[29,1345,1346],{"class":31,"line":188},[29,1347,1348],{"class":35},"\u002F\u002F Or with streams:\n",[29,1350,1352,1354,1356,1358,1361],{"class":31,"line":1351},14,[29,1353,381],{"class":42},[29,1355,579],{"class":53},[29,1357,582],{"class":42},[29,1359,1360],{"class":53},"stream",[29,1362,1363],{"class":42},"()\n",[29,1365,1367,1370,1373,1376,1379,1382,1385,1388],{"class":31,"line":1366},15,[29,1368,1369],{"class":42},"    .",[29,1371,1372],{"class":53},"filter",[29,1374,1375],{"class":42},"(x ",[29,1377,1378],{"class":46},"->",[29,1380,1381],{"class":42}," x ",[29,1383,1384],{"class":46},">",[29,1386,1387],{"class":60}," 2",[29,1389,1390],{"class":42},")\n",[29,1392,1394,1396,1398,1400,1402],{"class":31,"line":1393},16,[29,1395,1369],{"class":42},[29,1397,585],{"class":53},[29,1399,588],{"class":42},[29,1401,591],{"class":46},[29,1403,1243],{"class":42},[10,1405,1407],{"id":1406},"getfirst-vs-get0-whats-the-difference","getFirst() vs get(0) — what's the difference?",[15,1409,1410,1411,361,1413,483,1415,1418],{},"For ",[26,1412,974],{},[26,1414,204],{},[26,1416,1417],{},"get(0)"," return the same value but throw different\nexceptions on an empty list:",[19,1420,1422],{"className":21,"code":1421,"language":23,"meta":24,"style":24},"List\u003CString> empty = new ArrayList\u003C>();\n\nempty.get(0);      \u002F\u002F IndexOutOfBoundsException: Index: 0, Size: 0\nempty.getFirst();  \u002F\u002F NoSuchElementException\n",[26,1423,1424,1440,1444,1461],{"__ignoreMap":24},[29,1425,1426,1428,1430,1433,1435,1437],{"class":31,"line":32},[29,1427,335],{"class":42},[29,1429,338],{"class":46},[29,1431,1432],{"class":42},"> empty ",[29,1434,47],{"class":46},[29,1436,346],{"class":46},[29,1438,1439],{"class":42}," ArrayList\u003C>();\n",[29,1441,1442],{"class":31,"line":39},[29,1443,104],{"emptyLinePlaceholder":103},[29,1445,1446,1449,1451,1453,1455,1458],{"class":31,"line":67},[29,1447,1448],{"class":42},"empty.",[29,1450,54],{"class":53},[29,1452,57],{"class":42},[29,1454,61],{"class":60},[29,1456,1457],{"class":42},");      ",[29,1459,1460],{"class":35},"\u002F\u002F IndexOutOfBoundsException: Index: 0, Size: 0\n",[29,1462,1463,1465,1467,1469],{"class":31,"line":100},[29,1464,1448],{"class":42},[29,1466,384],{"class":53},[29,1468,470],{"class":42},[29,1470,1471],{"class":35},"\u002F\u002F NoSuchElementException\n",[15,1473,1474,1476,1477,1480,1481,1483,1484,1486,1487,1026],{},[26,1475,264],{}," better communicates \"there is no first element\" versus\n",[26,1478,1479],{},"IndexOutOfBoundsException"," which sounds like a bug in index arithmetic. Prefer\n",[26,1482,204],{}," for clarity, especially in generic code that receives a ",[26,1485,911],{},"\nand doesn't know if it's a ",[26,1488,974],{},[10,1490,1492],{"id":1491},"immutable-and-unmodifiable-collections","Immutable and unmodifiable collections",[15,1494,1495,1496,361,1498,361,1500,361,1502,1504,1505,1507],{},"Read-only methods (",[26,1497,384],{},[26,1499,397],{},[26,1501,825],{},[26,1503,837],{},") work on any\n",[26,1506,911],{}," including immutable ones:",[19,1509,1511],{"className":21,"code":1510,"language":23,"meta":24,"style":24},"List\u003CString> fixed = List.of(\"x\", \"y\", \"z\");\nfixed.getFirst(); \u002F\u002F \"x\" — fine\nfixed.getLast();  \u002F\u002F \"z\" — fine\nfixed.addFirst(\"a\"); \u002F\u002F UnsupportedOperationException — immutable\n",[26,1512,1513,1544,1556,1567],{"__ignoreMap":24},[29,1514,1515,1517,1519,1522,1524,1527,1529,1531,1533,1535,1538,1540,1542],{"class":31,"line":32},[29,1516,335],{"class":42},[29,1518,338],{"class":46},[29,1520,1521],{"class":42},"> fixed ",[29,1523,47],{"class":46},[29,1525,1526],{"class":42}," List.",[29,1528,352],{"class":53},[29,1530,57],{"class":42},[29,1532,437],{"class":357},[29,1534,361],{"class":42},[29,1536,1537],{"class":357},"\"y\"",[29,1539,361],{"class":42},[29,1541,419],{"class":357},[29,1543,64],{"class":42},[29,1545,1546,1549,1551,1553],{"class":31,"line":39},[29,1547,1548],{"class":42},"fixed.",[29,1550,384],{"class":53},[29,1552,457],{"class":42},[29,1554,1555],{"class":35},"\u002F\u002F \"x\" — fine\n",[29,1557,1558,1560,1562,1564],{"class":31,"line":67},[29,1559,1548],{"class":42},[29,1561,397],{"class":53},[29,1563,470],{"class":42},[29,1565,1566],{"class":35},"\u002F\u002F \"z\" — fine\n",[29,1568,1569,1571,1573,1575,1577,1579],{"class":31,"line":100},[29,1570,1548],{"class":42},[29,1572,414],{"class":53},[29,1574,57],{"class":42},[29,1576,358],{"class":357},[29,1578,422],{"class":42},[29,1580,1581],{"class":35},"\u002F\u002F UnsupportedOperationException — immutable\n",[15,1583,1584,1585,361,1587,361,1589,1591,1592,1595,1596,483,1599,1602],{},"Mutation methods (",[26,1586,414],{},[26,1588,454],{},[26,1590,853],{},", etc.) respect the collection's\nmodifiability contract and throw ",[26,1593,1594],{},"UnsupportedOperationException"," for unmodifiable\u002F\nimmutable collections, exactly as ",[26,1597,1598],{},"add()",[26,1600,1601],{},"remove()"," already do.",[10,1604,1606],{"id":1605},"sequencedcollection-in-method-signatures","SequencedCollection in method signatures",[15,1608,1609,1610,1612,1613,1616],{},"Use ",[26,1611,221],{}," in a method signature when your code specifically needs\nfirst\u002Flast access but doesn't need random index access (",[26,1614,1615],{},"get(i)","):",[19,1618,1620],{"className":21,"code":1619,"language":23,"meta":24,"style":24},"\u002F\u002F Good — accepts ArrayList, LinkedList, ArrayDeque, or any ordered collection:\nstatic \u003CT> T penultimate(SequencedCollection\u003CT> col) {\n    if (col.size() \u003C 2) throw new NoSuchElementException();\n    return col.reversed().stream().skip(1).findFirst().orElseThrow();\n}\n\n\u002F\u002F Too narrow — only accepts List:\nstatic \u003CT> T penultimate(List\u003CT> list) { ... }\n\n\u002F\u002F Too broad — Collection doesn't guarantee order:\nstatic \u003CT> T penultimate(Collection\u003CT> col) { ... } \u002F\u002F getFirst() unavailable\n",[26,1621,1622,1627,1659,1688,1723,1728,1732,1737,1763,1767,1772],{"__ignoreMap":24},[29,1623,1624],{"class":31,"line":32},[29,1625,1626],{"class":35},"\u002F\u002F Good — accepts ArrayList, LinkedList, ArrayDeque, or any ordered collection:\n",[29,1628,1629,1632,1635,1638,1640,1643,1646,1649,1652,1654,1656],{"class":31,"line":39},[29,1630,1631],{"class":46},"static",[29,1633,1634],{"class":46}," \u003C",[29,1636,1637],{"class":42},"T",[29,1639,1384],{"class":46},[29,1641,1642],{"class":42}," T ",[29,1644,1645],{"class":53},"penultimate",[29,1647,1648],{"class":42},"(SequencedCollection",[29,1650,1651],{"class":46},"\u003C",[29,1653,1637],{"class":42},[29,1655,1384],{"class":46},[29,1657,1658],{"class":42}," col) {\n",[29,1660,1661,1664,1667,1669,1671,1673,1675,1678,1681,1683,1686],{"class":31,"line":67},[29,1662,1663],{"class":46},"    if",[29,1665,1666],{"class":42}," (col.",[29,1668,82],{"class":53},[29,1670,85],{"class":42},[29,1672,1651],{"class":46},[29,1674,1387],{"class":60},[29,1676,1677],{"class":42},") ",[29,1679,1680],{"class":46},"throw",[29,1682,346],{"class":46},[29,1684,1685],{"class":53}," NoSuchElementException",[29,1687,126],{"class":42},[29,1689,1690,1693,1696,1698,1700,1702,1704,1707,1709,1711,1713,1716,1718,1721],{"class":31,"line":100},[29,1691,1692],{"class":46},"    return",[29,1694,1695],{"class":42}," col.",[29,1697,579],{"class":53},[29,1699,582],{"class":42},[29,1701,1360],{"class":53},[29,1703,582],{"class":42},[29,1705,1706],{"class":53},"skip",[29,1708,57],{"class":42},[29,1710,1065],{"class":60},[29,1712,499],{"class":42},[29,1714,1715],{"class":53},"findFirst",[29,1717,582],{"class":42},[29,1719,1720],{"class":53},"orElseThrow",[29,1722,126],{"class":42},[29,1724,1725],{"class":31,"line":107},[29,1726,1727],{"class":42},"}\n",[29,1729,1730],{"class":31,"line":113},[29,1731,104],{"emptyLinePlaceholder":103},[29,1733,1734],{"class":31,"line":129},[29,1735,1736],{"class":35},"\u002F\u002F Too narrow — only accepts List:\n",[29,1738,1739,1741,1743,1745,1747,1749,1751,1754,1756,1758,1760],{"class":31,"line":143},[29,1740,1631],{"class":46},[29,1742,1634],{"class":46},[29,1744,1637],{"class":42},[29,1746,1384],{"class":46},[29,1748,1642],{"class":42},[29,1750,1645],{"class":53},[29,1752,1753],{"class":42},"(List",[29,1755,1651],{"class":46},[29,1757,1637],{"class":42},[29,1759,1384],{"class":46},[29,1761,1762],{"class":42}," list) { ... }\n",[29,1764,1765],{"class":31,"line":148},[29,1766,104],{"emptyLinePlaceholder":103},[29,1768,1769],{"class":31,"line":154},[29,1770,1771],{"class":35},"\u002F\u002F Too broad — Collection doesn't guarantee order:\n",[29,1773,1774,1776,1778,1780,1782,1784,1786,1789,1791,1793,1795,1798],{"class":31,"line":169},[29,1775,1631],{"class":46},[29,1777,1634],{"class":46},[29,1779,1637],{"class":42},[29,1781,1384],{"class":46},[29,1783,1642],{"class":42},[29,1785,1645],{"class":53},[29,1787,1788],{"class":42},"(Collection",[29,1790,1651],{"class":46},[29,1792,1637],{"class":42},[29,1794,1384],{"class":46},[29,1796,1797],{"class":42}," col) { ... } ",[29,1799,1800],{"class":35},"\u002F\u002F getFirst() unavailable\n",[15,1802,1803,1805],{},[26,1804,911],{}," is the right abstraction when you care about order and\nfirst\u002Flast but not about array-like index access.",[10,1807,1809],{"id":1808},"replacing-deque-methods","Replacing Deque methods",[15,1811,1812,1814,1815,1014,1818,483,1821,1014,1824,1827,1828,1830,1831,1833,1834,1836,1837,1839],{},[26,1813,982],{}," already had ",[26,1816,1817],{},"peekFirst()",[26,1819,1820],{},"peekLast()",[26,1822,1823],{},"addFirst()",[26,1825,1826],{},"addLast()",". ",[26,1829,982],{}," now\nextends ",[26,1832,911],{},", so ",[26,1835,906],{}," has all the new methods too. The ",[26,1838,911],{},"\nequivalents are cleaner for non-queue uses:",[234,1841,1842,1852],{},[237,1843,1844],{},[240,1845,1846,1849],{},[243,1847,1848],{},"Old Deque API",[243,1850,1851],{},"New SequencedCollection API",[250,1853,1854,1866,1878,1890],{},[240,1855,1856,1861],{},[255,1857,1858],{},[26,1859,1860],{},"deque.peekFirst()",[255,1862,1863],{},[26,1864,1865],{},"deque.getFirst()",[240,1867,1868,1873],{},[255,1869,1870],{},[26,1871,1872],{},"deque.peekLast()",[255,1874,1875],{},[26,1876,1877],{},"deque.getLast()",[240,1879,1880,1885],{},[255,1881,1882],{},[26,1883,1884],{},"deque.pollFirst()",[255,1886,1887],{},[26,1888,1889],{},"deque.removeFirst()",[240,1891,1892,1897],{},[255,1893,1894],{},[26,1895,1896],{},"deque.pollLast()",[255,1898,1899],{},[26,1900,1901],{},"deque.removeLast()",[15,1903,1904,1905,1907,1908,1911,1912,1914,1915,1917],{},"Note: ",[26,1906,1817],{}," returns ",[26,1909,1910],{},"null"," for an empty deque; ",[26,1913,204],{}," throws\n",[26,1916,264],{},". Choose based on whether null vs exception is more appropriate.",[10,1919,1921],{"id":1920},"before-and-after-the-complete-comparison","Before and after — the complete comparison",[19,1923,1925],{"className":21,"code":1924,"language":23,"meta":24,"style":24},"\u002F\u002F BEFORE Java 21:\nList\u003CString>   list   = new ArrayList\u003C>(List.of(\"a\", \"b\", \"c\"));\nDeque\u003CString>  deque  = new ArrayDeque\u003C>(list);\nTreeSet\u003CString> sorted = new TreeSet\u003C>(list);\n\nString fl = list.get(0);              \u002F\u002F first from List\nString ll = list.get(list.size()-1);  \u002F\u002F last from List\nString fd = deque.peekFirst();        \u002F\u002F first from Deque\nString ld = deque.peekLast();         \u002F\u002F last from Deque\nString fs = sorted.first();           \u002F\u002F first from SortedSet\nString ls = sorted.last();            \u002F\u002F last from SortedSet\n\n\u002F\u002F AFTER Java 21 — uniform API:\nlist.getFirst();   \u002F\u002F \"a\"\nlist.getLast();    \u002F\u002F \"c\"\ndeque.getFirst();  \u002F\u002F \"a\"\ndeque.getLast();   \u002F\u002F \"c\"\nsorted.getFirst(); \u002F\u002F \"a\"\nsorted.getLast();  \u002F\u002F \"c\"\n\n\u002F\u002F Reverse without mutation:\nlist.reversed().forEach(System.out::println);   \u002F\u002F c, b, a\ndeque.reversed().forEach(System.out::println);  \u002F\u002F c, b, a\nsorted.reversed().forEach(System.out::println); \u002F\u002F c, b, a\n",[26,1926,1927,1932,1963,1980,1997,2001,2022,2049,2066,2083,2101,2118,2122,2127,2138,2148,2159,2170,2182,2193,2198,2204,2225,2244],{"__ignoreMap":24},[29,1928,1929],{"class":31,"line":32},[29,1930,1931],{"class":35},"\u002F\u002F BEFORE Java 21:\n",[29,1933,1934,1936,1938,1941,1943,1945,1947,1949,1951,1953,1955,1957,1959,1961],{"class":31,"line":39},[29,1935,335],{"class":42},[29,1937,338],{"class":46},[29,1939,1940],{"class":42},">   list   ",[29,1942,47],{"class":46},[29,1944,346],{"class":46},[29,1946,349],{"class":42},[29,1948,352],{"class":53},[29,1950,57],{"class":42},[29,1952,358],{"class":357},[29,1954,361],{"class":42},[29,1956,364],{"class":357},[29,1958,361],{"class":42},[29,1960,369],{"class":357},[29,1962,372],{"class":42},[29,1964,1965,1968,1970,1973,1975,1977],{"class":31,"line":67},[29,1966,1967],{"class":42},"Deque\u003C",[29,1969,338],{"class":46},[29,1971,1972],{"class":42},">  deque  ",[29,1974,47],{"class":46},[29,1976,346],{"class":46},[29,1978,1979],{"class":42}," ArrayDeque\u003C>(list);\n",[29,1981,1982,1985,1987,1990,1992,1994],{"class":31,"line":100},[29,1983,1984],{"class":42},"TreeSet\u003C",[29,1986,338],{"class":46},[29,1988,1989],{"class":42},"> sorted ",[29,1991,47],{"class":46},[29,1993,346],{"class":46},[29,1995,1996],{"class":42}," TreeSet\u003C>(list);\n",[29,1998,1999],{"class":31,"line":107},[29,2000,104],{"emptyLinePlaceholder":103},[29,2002,2003,2006,2008,2010,2012,2014,2016,2019],{"class":31,"line":113},[29,2004,2005],{"class":42},"String fl ",[29,2007,47],{"class":46},[29,2009,50],{"class":42},[29,2011,54],{"class":53},[29,2013,57],{"class":42},[29,2015,61],{"class":60},[29,2017,2018],{"class":42},");              ",[29,2020,2021],{"class":35},"\u002F\u002F first from List\n",[29,2023,2024,2027,2029,2031,2033,2035,2037,2040,2042,2044,2046],{"class":31,"line":129},[29,2025,2026],{"class":42},"String ll ",[29,2028,47],{"class":46},[29,2030,50],{"class":42},[29,2032,54],{"class":53},[29,2034,79],{"class":42},[29,2036,82],{"class":53},[29,2038,2039],{"class":42},"()",[29,2041,88],{"class":46},[29,2043,1065],{"class":60},[29,2045,440],{"class":42},[29,2047,2048],{"class":35},"\u002F\u002F last from List\n",[29,2050,2051,2054,2056,2058,2060,2063],{"class":31,"line":143},[29,2052,2053],{"class":42},"String fd ",[29,2055,47],{"class":46},[29,2057,120],{"class":42},[29,2059,123],{"class":53},[29,2061,2062],{"class":42},"();        ",[29,2064,2065],{"class":35},"\u002F\u002F first from Deque\n",[29,2067,2068,2071,2073,2075,2077,2080],{"class":31,"line":148},[29,2069,2070],{"class":42},"String ld ",[29,2072,47],{"class":46},[29,2074,120],{"class":42},[29,2076,138],{"class":53},[29,2078,2079],{"class":42},"();         ",[29,2081,2082],{"class":35},"\u002F\u002F last from Deque\n",[29,2084,2085,2088,2090,2093,2095,2098],{"class":31,"line":154},[29,2086,2087],{"class":42},"String fs ",[29,2089,47],{"class":46},[29,2091,2092],{"class":42}," sorted.",[29,2094,164],{"class":53},[29,2096,2097],{"class":42},"();           ",[29,2099,2100],{"class":35},"\u002F\u002F first from SortedSet\n",[29,2102,2103,2106,2108,2110,2112,2115],{"class":31,"line":169},[29,2104,2105],{"class":42},"String ls ",[29,2107,47],{"class":46},[29,2109,2092],{"class":42},[29,2111,178],{"class":53},[29,2113,2114],{"class":42},"();            ",[29,2116,2117],{"class":35},"\u002F\u002F last from SortedSet\n",[29,2119,2120],{"class":31,"line":183},[29,2121,104],{"emptyLinePlaceholder":103},[29,2123,2124],{"class":31,"line":188},[29,2125,2126],{"class":35},"\u002F\u002F AFTER Java 21 — uniform API:\n",[29,2128,2129,2131,2133,2136],{"class":31,"line":1351},[29,2130,381],{"class":42},[29,2132,384],{"class":53},[29,2134,2135],{"class":42},"();   ",[29,2137,390],{"class":35},[29,2139,2140,2142,2144,2146],{"class":31,"line":1366},[29,2141,381],{"class":42},[29,2143,397],{"class":53},[29,2145,387],{"class":42},[29,2147,403],{"class":35},[29,2149,2150,2153,2155,2157],{"class":31,"line":1393},[29,2151,2152],{"class":42},"deque.",[29,2154,384],{"class":53},[29,2156,470],{"class":42},[29,2158,390],{"class":35},[29,2160,2162,2164,2166,2168],{"class":31,"line":2161},17,[29,2163,2152],{"class":42},[29,2165,397],{"class":53},[29,2167,2135],{"class":42},[29,2169,403],{"class":35},[29,2171,2173,2176,2178,2180],{"class":31,"line":2172},18,[29,2174,2175],{"class":42},"sorted.",[29,2177,384],{"class":53},[29,2179,457],{"class":42},[29,2181,390],{"class":35},[29,2183,2185,2187,2189,2191],{"class":31,"line":2184},19,[29,2186,2175],{"class":42},[29,2188,397],{"class":53},[29,2190,470],{"class":42},[29,2192,403],{"class":35},[29,2194,2196],{"class":31,"line":2195},20,[29,2197,104],{"emptyLinePlaceholder":103},[29,2199,2201],{"class":31,"line":2200},21,[29,2202,2203],{"class":35},"\u002F\u002F Reverse without mutation:\n",[29,2205,2207,2209,2211,2213,2215,2217,2219,2222],{"class":31,"line":2206},22,[29,2208,381],{"class":42},[29,2210,579],{"class":53},[29,2212,582],{"class":42},[29,2214,585],{"class":53},[29,2216,588],{"class":42},[29,2218,591],{"class":46},[29,2220,2221],{"class":42},"println);   ",[29,2223,2224],{"class":35},"\u002F\u002F c, b, a\n",[29,2226,2228,2230,2232,2234,2236,2238,2240,2242],{"class":31,"line":2227},23,[29,2229,2152],{"class":42},[29,2231,579],{"class":53},[29,2233,582],{"class":42},[29,2235,585],{"class":53},[29,2237,588],{"class":42},[29,2239,591],{"class":46},[29,2241,1336],{"class":42},[29,2243,2224],{"class":35},[29,2245,2247,2249,2251,2253,2255,2257,2259,2261],{"class":31,"line":2246},24,[29,2248,2175],{"class":42},[29,2250,579],{"class":53},[29,2252,582],{"class":42},[29,2254,585],{"class":53},[29,2256,588],{"class":42},[29,2258,591],{"class":46},[29,2260,594],{"class":42},[29,2262,2224],{"class":35},[10,2264,2266],{"id":2265},"recap","Recap",[15,2268,2269,2271,2272,2274,2275,1007,2277,2279,2280,2283,2284,1014,2286,2288,2289,205,2291,2294,2295,1014,2297,1014,2299,1014,2301,2303,2304,2306,2307,2309,2310,1035,2312,2315,2316,361,2318,361,2320,361,2322,361,2324,2326],{},[198,2270,200],{}," (Java 21) add three interfaces — ",[26,2273,911],{},",\n",[26,2276,922],{},[26,2278,948],{}," — that provide a ",[198,2281,2282],{},"uniform API"," for first\u002Flast\naccess and reverse iteration across all ordered collections. ",[26,2285,204],{},[26,2287,208],{},"\nreplace ",[26,2290,1417],{},[26,2292,2293],{},"get(size-1)"," with clearer semantics and a better exception type.\n",[26,2296,1823],{},[26,2298,1826],{},[26,2300,303],{},[26,2302,313],{}," mirror the ",[26,2305,982],{}," API on all\n",[26,2308,974],{}," implementations. ",[26,2311,211],{},[198,2313,2314],{},"live write-through view"," — not a copy —\nthat reflects mutations in both directions. The interfaces are retrofitted onto\n",[26,2317,900],{},[26,2319,490],{},[26,2321,494],{},[26,2323,943],{},[26,2325,955],{},", and their parent\ninterfaces, so you get the new methods without any code changes.",[2328,2329,2330],"style",{},"html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}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 .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);}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}",{"title":24,"searchDepth":39,"depth":39,"links":2332},[2333,2334,2339,2340,2343,2344,2345,2346,2347,2348],{"id":12,"depth":39,"text":13},{"id":215,"depth":39,"text":216,"children":2335},[2336,2337,2338],{"id":220,"depth":67,"text":221},{"id":476,"depth":67,"text":477},{"id":600,"depth":67,"text":601},{"id":871,"depth":39,"text":872},{"id":1029,"depth":39,"text":1030,"children":2341},[2342],{"id":1198,"depth":67,"text":1199},{"id":1406,"depth":39,"text":1407},{"id":1491,"depth":39,"text":1492},{"id":1605,"depth":39,"text":1606},{"id":1808,"depth":39,"text":1809},{"id":1920,"depth":39,"text":1921},{"id":2265,"depth":39,"text":2266},"Complete guide to Java 21 sequenced collections — SequencedCollection, SequencedSet, and SequencedMap interfaces, getFirst\u002FgetLast\u002FaddFirst\u002FaddLast, reversed() live views, which existing types implement the new interfaces, and replacing pre-Java-21 workarounds.","easy","md","Java",{},"\u002Fblog\u002Fjava-sequenced-collections","\u002Fjava\u002Fmodern-java\u002Fsequenced-collections",{"title":5,"description":2349},"blog\u002Fjava-sequenced-collections","Sequenced Collections","Modern Java","modern-java","2026-06-20","v0IYS2Sarg22YPK4UJ1yvmgwwHpDAuS7ODfP_cUlYDo",1782244091904]