列表（List）

list<T> 是可增长序列，是最常用的容器。长度随增删变化，可按下标读写。

小写 list 是内建名，免 import 直接可用。标准库的声明名是大写 List<T>（std::Collections 模块内）。

创建

两种创建路径：构造器加 Add，或集合字面量按目标类型构造：


val xs = new list<int>();
xs.Add(3);
xs.Add(1);
xs.Add(2);
print(xs, xs.Count);
 
val ys: list<int> = [4, 5];


[3, 1, 2] 3

Note

集合字面量无注解时默认推断为数组，想要列表必须显式注解 list<T>。

增删改


xs.Insert(1, 99);
print(xs);
xs.Set(0, 30);
xs[1] = 10;
print(xs);
xs.Remove(30);
xs.RemoveAt(0);
print(xs);


[3, 99, 1, 2]
[30, 10, 1, 2]
[1, 2]

Insert(位置, 值) 在下标处插入；Set(下标, 值) 与索引器写 xs[下标] = 值 等价；Remove(值) 删第一个匹配，RemoveAt(下标) 按位置删。批量追加用 AddRange(other)，清空用 Clear()。

读取与查找


print(xs[1], xs.Contains(2), xs.IndexOf(2));
print(try? xs.Get(9));


2 True 1
null

Note

IndexOf 未命中返回 -1。

容器取值面有两种：


xs[1]                     // 断言形：越界直接崩溃，确信在的时候用
try xs.Get(9)             // fail 形：越界会触发IndexOutOfRange，必须配 try 系消费
try? xs.Get(9)            // 吞失败 → null
try? xs.Get(9) ?? -1      // 也可以直接处理 null，落默认值

标准组合：


val hp = try? enemies.Get(i)?.Hp ?? 0;           // 越界安全读
if try? items.Get(k) is Item it { use(it); }       // is 分型 + 收窄
val name = try? names.Get(0) ?? "?";             // ?? 兜底

高阶方法面

查找、变换、聚合都有现成方法，接 lambda：


xs.Insert(0, 30);
xs.Insert(1, 10);
print(xs);
print(xs.Where(n => n > 5), xs.Map(n => n * 2));
print(xs.Filter(n => n % 2 == 0), xs.Reduce((a, b) => a + b, 0));
print(xs.Min(), xs.Max(), xs.Sum());
print(xs.Any(n => n > 100), xs.All(n => n > 0));
print(try? xs.First(n => n > 50));


[30, 10, 1, 2]
[30, 10] [60, 20, 2, 4]
[30, 10, 2] 43
1 30 43
False True
null

Where 与 Filter 同义，都返回新列表。
Map 逐元素变换；Reduce 带种子折叠。
First(pred) 无命中则 fail SeqEmpty。
FindIndex(pred)、LastIndexOf(v) 各自负责一类查找（未命中 -1）。

空表取首的惯用式：


val singles: list<int> = [7];
print(try? singles.First() ?? 0);
val empty = new list<int>();
print(try? empty.First() ?? 0, try? empty.Last() ?? -1);


7
0 -1

排序与整理


print(xs.Sorted(), xs.Reversed(), xs.Distinct());
print(xs.Take(2), xs.Skip(1));


[1, 2, 10, 30] [2, 1, 10, 30] [30, 10, 1, 2]
[30, 10] [10, 1, 2]

Sorted() / Reversed() / Distinct() / Take(n) / Skip(n) 都返回新列表，原列表不动。原位排序用 Sort()，原位反转用 Reverse()。

拼接、配对与转换


print(xs.Join("-"));
val zs: list<int> = [7];
print(xs.Zip(zs));
print(xs.ToArray().Length);


30-10-1-2
[(30, 7)]
4

Join(分隔符) 拼成字符串，Zip(other) 把两个列表按位配对成元组列表，结果长度取较短一方，ToList() 拷贝一份新列表，ToArray() 转成定长数组，ToSet() 转集合去重。

注意

打印出的列表形态就是方括号加逗号：[1, 2, 3]。
for x in xs 直接遍历，见迭代协议。
元素判等与容器判等（值语义比值、引用语义比身份）见判等与哈希。