在F＃中，列表是相同类型的有序，不可变系列元素。 它在某种程度上等同于链表数据结构。
F＃模块Microsoft.FSharp.Collections.List具有对列表的常见操作。 但是，F＃自动导入此模块，并使其可访问每个F＃应用程序。

创建和初始化列表

以下是创建列表的各种方式 

• 使用List Literals。

• 使用cons(::)运算符。

• 使用List模块的List.init方法。

• 使用一些名为List Comprehension的句法结构。

使用List Literals

在此方法中，您只需在方括号中指定以分号分隔的值序列。 例如

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

使用cons(::)运算符

使用此方法，可以通过使用::运算符将orcons-ingit添加到现有列表来添加一些值。 例如 

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

[]表示空列表。

使用List模块的List.init方法

列表模块的List.init方法通常用于创建列表。这种方法具有的类型 

val init : int -> (int -> 'T) -> 'T list

第一个参数是新的列表中所需的长度，第二个参数是一个初始化函数，产生列表中的项目。

例如，

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

在这里，指数函数生成的列表中。

列表解析

列表推导是用于生成列表的特殊句法结构。
F＃列表解析语法有两种形式 - 范围和生成器。
范围有构造 - [start .. end]和[start .. step .. end]
例如，

let list3 = [1 .. 10]

生成器有构造 - [for x in collection do ... yield expr]
例如，

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

当theyieldkeyword将单个值推入列表时，关键字yield！将一组值推送到列表中。
以下函数演示了上述方法 -

例

(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1

(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2

(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3

(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4

(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5

(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6

(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7

(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8

当你编译和执行程序，它产生以下输出 

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]

列表数据类型属性

下表显示列表数据类型的各种属性 

属性	类型	描述
Head	'T	第一个元素。
Empty	'T list	静态属性，返回相应类型的空列表。
IsEmpty	bool	ture，如果列表中没有的元素。
Item	'T	（从零开始）指定索引处的元素。
Length	int	元素的数量。
Tail	'T list	没有第一元件列表。

下面的例子说明了如何使用这些属性 

例

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]

// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))

当你编译和执行程序，它产生以下输出 -

list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4

列表上的基本运算

下表显示了在列表数据类型的基本操作 

值	描述
append : 'T list → 'T list → 'T list	返回包含第一列表，随后通过第二元素的元素的新列表。
average : 'T list → ^T	返回列表中的元素的平均值。
averageBy : ('T → ^U) → 'T list → ^U	返回由将所述函数应用于所述列表中的每个元件产生的元素的平均。
choose : ('T → 'U option) → 'T list → 'U list	应用于给定的功能，以该列表的每个元素。返回包含的结果，其中函数返回部分的各元素的列表。
collect : ('T → 'U list) → 'T list → 'U list	对于列表中的每个元素，应用于给定的功能。串联所有的结果和回报组合列表。
concat : seq<'T list> → 'T list	返回包含在顺序中的每个列表中的元素的新列表。
empty : 'T list	返回给定类型的空列表。
exists : ('T → bool) → 'T list → bool	测试如果列表中的任何元素满足给定谓词。
exists2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	测试如果任何一对列表的相应元素的满足给定谓词。
filter : ('T → bool) → 'T list → 'T list	返回包含只对给定的谓词返回true的集合中的元素一个新的集合。
find : ('T → bool) → 'T list → 'T	返回该给定函数返回true的第一个元素。
findIndex : ('T → bool) → 'T list → int	返回满足给定谓词列表中的第一个元素的索引。
fold : ('State → 'T → 'State) → 'State → 'T list → 'State	应用一个函数集合中的每个元素，穿线通过计算一个累加器参数。这个函数的第二个参数，函数适用该列表的第一个元素。然后，它通过该结果到函数与第二元件沿，等等。最后，它返回最终结果。如果输入函数是f和元素I0 ...中，则该函数计算F（...（FS I0）的i1 ...）中。
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 list → 'T2 list → 'State	适用于相应的两个集合元素，穿线通过计算累加器参数的函数。藏品必须具有相同的尺寸。如果输入函数是f和元素I0 ... In和J0 ... JN，则该函数计算F（...（FS I0 J0）...）中JN。
foldBack : ('T → 'State → 'State) → 'T list → 'State → 'State	应用一个函数集合中的每个元素，穿线通过计算一个累加器参数。如果输入功能ISF和元素I0 ...在随后计算˚FI0（...（F IN S））。
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 list → 'T2 list → 'State → 'State	适用于相应的两个集合元素，穿线通过计算累加器参数的函数。藏品必须具有相同的尺寸。如果输入函数是f和元素I0 ... In和J0 ... JN，则该函数计算˚FI0 J0（...（F在JN多个））。
forall : ('T → bool) → 'T list → bool	测试如果集合中的所有元素满足给定谓词。
forall2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	如果测试收集的所有相应的元素满足给定谓词配对。
head : 'T list → 'T	返回列表的第一个元素。
init : int → (int → 'T) → 'T list	通过调用每个指标给定生成器创建一个列表。
isEmpty : 'T list → bool	如果列表中不包含任何元素， 则返回True。
iter : ('T → unit) → 'T list → unit	应用于给定的功能到集合中的每个元素。
iter2 : ('T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	适用于给定函数同时两个集合。藏品必须具有相同的大小。
iteri : (int → 'T → unit) → 'T list → unit	应用于给定的功能到集合中的每个元素。传递给函数的整数表示的元素的索引。
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	适用于给定函数同时两个集合。藏品必须具有相同的大小。传递给函数的整数表示的元素的索引。
length : 'T list → int	返回列表的长度。
map : ('T → 'U) → 'T list → 'U list	创建一个新的集合的元素是施加给定函数对每个集合中的元素的结果。
map2 : ('T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	创建一个新的集合的元素是施加给定函数对两个集合成对的相应元素的结果。
map3 : ('T1 → 'T2 → 'T3 → 'U) → 'T1 list → 'T2 list → 'T3 list → 'U list	创建一个新的集合，其元素是应用特定功能，同时三个集合的相应元素的结果。
mapi : (int → 'T → 'U) → 'T list → 'U list	创建一个新的集合的元素是施加给定函数对每个集合中的元素的结果。传递给函数的整数索引表示正在转变元素的索引（从0开始）。
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	像List.mapi，但映射对应从长度相等的两个列表元素。
max : 'T list → 'T	返回的最大的列表的所有元素，通过使用Operators.max比较。
maxBy : ('T → 'U) → 'T list → 'T	返回的最大的列表的所有元素，通过在函数结果使用Operators.max比较。
min : 'T list → 'T	返回最低列表的所有元素，通过使用Operators.min比较。
minBy : ('T → 'U) → 'T list → 'T	返回最低列表的所有元素，通过在函数结果使用Operators.min比较
nth : 'T list → int → 'T	索引到列表。第一个元素的索引为0。
ofArray : 'T [] → 'T list	创建一个从给定的数组列表。
ofSeq : seq<'T> → 'T list	创建从给定的枚举对象的新列表。
partition : ('T → bool) → 'T list * 'T list	拆分集合为两个集合，包含为其指定谓词分别返回true和false的元素。
permute : (int → int) → 'T list → 'T list	返回根据指定的排列置换所有单元的明细表。
pick : ('T → 'U option) → 'T list → 'U	适用于给定函数连续元素，返回的第一个结果，其中函数返回有的为一定的价值。
reduce : ('T → 'T → 'T) → 'T list → 'T	应用一个函数集合中的每个元素，穿线通过计算一个累加器参数。这个功能适用于指定的函数到列表的前两个元素。然后将其传递该结果到函数与第三元件沿，等等。最后，它返回最终结果。如果输入函数是f和元素I0 ...中，则该函数计算F（...（六I0的i1）12 ...）中。
reduceBack : ('T → 'T → 'T) → 'T list → 'T	应用一个函数集合中的每个元素，穿线通过计算一个累加器参数。如果输入功能ISF和元素I0 ...在，那么这个函数计算˚FI0（...（F IN-1））。
replicate : (int → 'T → 'T list)	通过调用每个指标给定生成器创建一个列表。
rev : 'T list → 'T list	返回与以相反的顺序元素的新名单。
scan : ('State → 'T → 'State) → 'State → 'T list → 'State list	应用一个函数集合中的每个元素，穿线通过计算一个累加器参数。这个函数的第二个参数，指定的函数适用该列表的第一个元素。然后，它通过这个结果与第二元件等沿功能。最后，它返回的中间结果和最终结果列表。
scanBack : ('T → 'State → 'State) → 'T list → 'State → 'State list	像折返，但同时返回中间结果和最终结果
sort : 'T list → 'T list	使用排序的Operators.compare给定的列表。
sortBy : ('T → 'Key) → 'T list → 'T list	使用排序由给定的投影给钥匙给定列表中。按键使用Operators.compare比较。
sortWith：（'T→'T→INT）→'T列表→'T名单	排序使用给定的比较函数给定列表中。
sum : ^T list → ^T	返回列表中的元素的总和。
sumBy : ('T → ^U) → 'T list → ^U	返回由将所述函数应用于所述列表中的每个元件产生的结果的总和。
tail : 'T list → 'T list	返回而不第一元件输入列表。
toArray : 'T list → 'T []	创建一个从给定列表中的数组。
toSeq : 'T list → seq<'T>	意见给出列表作为序列。
tryFind : ('T → bool) → 'T list → 'T option	返回该给定函数返回true的第一个元素。如果没有这样的元素存在返回无 。
tryFindIndex : ('T → bool) → 'T list → int option	返回满足给定谓词列表中的第一个元素的索引。如果没有这样的元素存在返回无 。
tryPick : ('T → 'U option) → 'T list → 'U option	适用于给定函数连续元素，返回的第一个结果，其中函数返回有的为一定的价值。如果没有这样的元素存在，那么返回None。
unzip : ('T1 * 'T2) list → 'T1 list * 'T2 list	拆分对列表分为两个列表。
unzip3 : ('T1 * 'T2 * 'T3) list → 'T1 list * 'T2 list * 'T3 list	三元拆分的名单分为三个列表。
zip : 'T1 list → 'T2 list → ('T1 * 'T2) list	结合了两个列表成为对的列表。这两个数组必须有相等的长度。
zip3 : 'T1 list → 'T2 list → 'T3 list → ('T1 * 'T2 * 'T3) list	将三个列表到三倍的名单。名单必须有平等的长度。

下面的例子演示了上述功能的用途 

例1

该程序显示递归扭转名单 

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1

let reverse lt =
   let rec loop acc = function
      | [] -> acc
      | hd :: tl -> loop (hd :: acc) tl
   loop [] lt

printfn "The reversed list: %A" (reverse list1)

当你编译和执行程序，它产生以下输出 

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

但是，您可以使用同样的目的模块的功能REV 

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

当你编译和执行程序，它产生以下输出 

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

例2

这个程序显示使用List.filtermethod过滤列表 

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2

当你编译和执行程序，它产生以下输出 

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

例3

所述List.map方法映射从一种类型到另一个列表

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2

当你编译和执行程序，它产生以下输出 

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]

例4

该List.append方法和@运算符追加一个列表到另一个

let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2

printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3

let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2

printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3

当你编译和执行程序，它产生以下输出 

The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']

例5

该List.sort方法排序列表。该List.sum方法给出了列表和List.average方法元素的总和给出列表元素的平均

let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1

let list2 = List.sort list1
printfn "The sorted list: %A" list2

let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avg

当你编译和执行程序，它产生以下输出 

The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857

A“折叠”的操作应用一个函数中的每个元素的列表，聚集在一个累加器变量的函数的结果，并返回累加器为折叠操作的结果。

例6

所述List.fold方法适用于从左至右每个元件的功能，同时List.foldBack应用一个函数由右至左的每个元素。

let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])

当你编译和执行程序，它产生以下输出 

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.