F＃列表

在F＃中，列表是相同類型的有序，不可變系列元素。 它在某種程度上等同于鏈表數(shù)據(jù)結(jié)構(gòu)。
F＃模塊Microsoft.FSharp.Collections.List具有對列表的常見操作。 但是，F(xiàn)＃自動導(dǎo)入此模塊，并使其可訪問每個F＃應(yīng)用程序。

創(chuàng)建和初始化列表

以下是創(chuàng)建列表的各種方式 

• 使用List Literals。

• 使用cons(::)運(yùn)算符。

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

• 使用一些名為List Comprehension的句法結(jié)構(gòu)。

使用List Literals

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

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

使用cons(::)運(yùn)算符

使用此方法，可以通過使用::運(yùn)算符將orcons-ingit添加到現(xiàn)有列表來添加一些值。 例如 

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

[]表示空列表。

使用List模塊的List.init方法

列表模塊的List.init方法通常用于創(chuàng)建列表。這種方法具有的類型 

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

第一個參數(shù)是新的列表中所需的長度，第二個參數(shù)是一個初始化函數(shù)，產(chǎn)生列表中的項(xiàng)目。

例如，

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

在這里，指數(shù)函數(shù)生成的列表中。

列表解析

列表推導(dǎo)是用于生成列表的特殊句法結(jié)構(gòu)。
F＃列表解析語法有兩種形式 - 范圍和生成器。
范圍有構(gòu)造 - [start .. end]和[start .. step .. end]
例如，

let list3 = [1 .. 10]

生成器有構(gòu)造 - [for x in collection do ... yield expr]
例如，

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

當(dāng)theyieldkeyword將單個值推入列表時，關(guān)鍵字yield！將一組值推送到列表中。
以下函數(shù)演示了上述方法 -

例

(* 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

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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]

列表數(shù)據(jù)類型屬性

下表顯示列表數(shù)據(jù)類型的各種屬性 

屬性	類型	描述
Head	'T	第一個元素。
Empty	'T list	靜態(tài)屬性，返回相應(yīng)類型的空列表。
IsEmpty	bool	ture，如果列表中沒有的元素。
Item	'T	（從零開始）指定索引處的元素。
Length	int	元素的數(shù)量。
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))

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 -

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

列表上的基本運(yùn)算

下表顯示了在列表數(shù)據(jù)類型的基本操作 

值	描述
append : 'T list → 'T list → 'T list	返回包含第一列表，隨后通過第二元素的元素的新列表。
average : 'T list → ^T	返回列表中的元素的平均值。
averageBy : ('T → ^U) → 'T list → ^U	返回由將所述函數(shù)應(yīng)用于所述列表中的每個元件產(chǎn)生的元素的平均。
choose : ('T → 'U option) → 'T list → 'U list	應(yīng)用于給定的功能，以該列表的每個元素。返回包含的結(jié)果，其中函數(shù)返回部分的各元素的列表。
collect : ('T → 'U list) → 'T list → 'U list	對于列表中的每個元素，應(yīng)用于給定的功能。串聯(lián)所有的結(jié)果和回報組合列表。
concat : seq<'T list> → 'T list	返回包含在順序中的每個列表中的元素的新列表。
empty : 'T list	返回給定類型的空列表。
exists : ('T → bool) → 'T list → bool	測試如果列表中的任何元素滿足給定謂詞。
exists2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	測試如果任何一對列表的相應(yīng)元素的滿足給定謂詞。
filter : ('T → bool) → 'T list → 'T list	返回包含只對給定的謂詞返回true的集合中的元素一個新的集合。
find : ('T → bool) → 'T list → 'T	返回該給定函數(shù)返回true的第一個元素。
findIndex : ('T → bool) → 'T list → int	返回滿足給定謂詞列表中的第一個元素的索引。
fold : ('State → 'T → 'State) → 'State → 'T list → 'State	應(yīng)用一個函數(shù)集合中的每個元素，穿線通過計(jì)算一個累加器參數(shù)。這個函數(shù)的第二個參數(shù)，函數(shù)適用該列表的第一個元素。然后，它通過該結(jié)果到函數(shù)與第二元件沿，等等。最后，它返回最終結(jié)果。如果輸入函數(shù)是f和元素I0 ...中，則該函數(shù)計(jì)算F（...（FS I0）的i1 ...）中。
fold2 : ('State → 'T1 → 'T2 → 'State) → 'State → 'T1 list → 'T2 list → 'State	適用于相應(yīng)的兩個集合元素，穿線通過計(jì)算累加器參數(shù)的函數(shù)。藏品必須具有相同的尺寸。如果輸入函數(shù)是f和元素I0 ... In和J0 ... JN，則該函數(shù)計(jì)算F（...（FS I0 J0）...）中JN。
foldBack : ('T → 'State → 'State) → 'T list → 'State → 'State	應(yīng)用一個函數(shù)集合中的每個元素，穿線通過計(jì)算一個累加器參數(shù)。如果輸入功能ISF和元素I0 ...在隨后計(jì)算?FI0（...（F IN S））。
foldBack2 : ('T1 → 'T2 → 'State → 'State) → 'T1 list → 'T2 list → 'State → 'State	適用于相應(yīng)的兩個集合元素，穿線通過計(jì)算累加器參數(shù)的函數(shù)。藏品必須具有相同的尺寸。如果輸入函數(shù)是f和元素I0 ... In和J0 ... JN，則該函數(shù)計(jì)算?FI0 J0（...（F在JN多個））。
forall : ('T → bool) → 'T list → bool	測試如果集合中的所有元素滿足給定謂詞。
forall2 : ('T1 → 'T2 → bool) → 'T1 list → 'T2 list → bool	如果測試收集的所有相應(yīng)的元素滿足給定謂詞配對。
head : 'T list → 'T	返回列表的第一個元素。
init : int → (int → 'T) → 'T list	通過調(diào)用每個指標(biāo)給定生成器創(chuàng)建一個列表。
isEmpty : 'T list → bool	如果列表中不包含任何元素， 則返回True。
iter : ('T → unit) → 'T list → unit	應(yīng)用于給定的功能到集合中的每個元素。
iter2 : ('T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	適用于給定函數(shù)同時兩個集合。藏品必須具有相同的大小。
iteri : (int → 'T → unit) → 'T list → unit	應(yīng)用于給定的功能到集合中的每個元素。傳遞給函數(shù)的整數(shù)表示的元素的索引。
iteri2 : (int → 'T1 → 'T2 → unit) → 'T1 list → 'T2 list → unit	適用于給定函數(shù)同時兩個集合。藏品必須具有相同的大小。傳遞給函數(shù)的整數(shù)表示的元素的索引。
length : 'T list → int	返回列表的長度。
map : ('T → 'U) → 'T list → 'U list	創(chuàng)建一個新的集合的元素是施加給定函數(shù)對每個集合中的元素的結(jié)果。
map2 : ('T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	創(chuàng)建一個新的集合的元素是施加給定函數(shù)對兩個集合成對的相應(yīng)元素的結(jié)果。
map3 : ('T1 → 'T2 → 'T3 → 'U) → 'T1 list → 'T2 list → 'T3 list → 'U list	創(chuàng)建一個新的集合，其元素是應(yīng)用特定功能，同時三個集合的相應(yīng)元素的結(jié)果。
mapi : (int → 'T → 'U) → 'T list → 'U list	創(chuàng)建一個新的集合的元素是施加給定函數(shù)對每個集合中的元素的結(jié)果。傳遞給函數(shù)的整數(shù)索引表示正在轉(zhuǎn)變元素的索引（從0開始）。
mapi2 : (int → 'T1 → 'T2 → 'U) → 'T1 list → 'T2 list → 'U list	像List.mapi，但映射對應(yīng)從長度相等的兩個列表元素。
max : 'T list → 'T	返回的最大的列表的所有元素，通過使用Operators.max比較。
maxBy : ('T → 'U) → 'T list → 'T	返回的最大的列表的所有元素，通過在函數(shù)結(jié)果使用Operators.max比較。
min : 'T list → 'T	返回最低列表的所有元素，通過使用Operators.min比較。
minBy : ('T → 'U) → 'T list → 'T	返回最低列表的所有元素，通過在函數(shù)結(jié)果使用Operators.min比較
nth : 'T list → int → 'T	索引到列表。第一個元素的索引為0。
ofArray : 'T [] → 'T list	創(chuàng)建一個從給定的數(shù)組列表。
ofSeq : seq<'T> → 'T list	創(chuàng)建從給定的枚舉對象的新列表。
partition : ('T → bool) → 'T list * 'T list	拆分集合為兩個集合，包含為其指定謂詞分別返回true和false的元素。
permute : (int → int) → 'T list → 'T list	返回根據(jù)指定的排列置換所有單元的明細(xì)表。
pick : ('T → 'U option) → 'T list → 'U	適用于給定函數(shù)連續(xù)元素，返回的第一個結(jié)果，其中函數(shù)返回有的為一定的價值。
reduce : ('T → 'T → 'T) → 'T list → 'T	應(yīng)用一個函數(shù)集合中的每個元素，穿線通過計(jì)算一個累加器參數(shù)。這個功能適用于指定的函數(shù)到列表的前兩個元素。然后將其傳遞該結(jié)果到函數(shù)與第三元件沿，等等。最后，它返回最終結(jié)果。如果輸入函數(shù)是f和元素I0 ...中，則該函數(shù)計(jì)算F（...（六I0的i1）12 ...）中。
reduceBack : ('T → 'T → 'T) → 'T list → 'T	應(yīng)用一個函數(shù)集合中的每個元素，穿線通過計(jì)算一個累加器參數(shù)。如果輸入功能ISF和元素I0 ...在，那么這個函數(shù)計(jì)算?FI0（...（F IN-1））。
replicate : (int → 'T → 'T list)	通過調(diào)用每個指標(biāo)給定生成器創(chuàng)建一個列表。
rev : 'T list → 'T list	返回與以相反的順序元素的新名單。
scan : ('State → 'T → 'State) → 'State → 'T list → 'State list	應(yīng)用一個函數(shù)集合中的每個元素，穿線通過計(jì)算一個累加器參數(shù)。這個函數(shù)的第二個參數(shù)，指定的函數(shù)適用該列表的第一個元素。然后，它通過這個結(jié)果與第二元件等沿功能。最后，它返回的中間結(jié)果和最終結(jié)果列表。
scanBack : ('T → 'State → 'State) → 'T list → 'State → 'State list	像折返，但同時返回中間結(jié)果和最終結(jié)果
sort : 'T list → 'T list	使用排序的Operators.compare給定的列表。
sortBy : ('T → 'Key) → 'T list → 'T list	使用排序由給定的投影給鑰匙給定列表中。按鍵使用Operators.compare比較。
sortWith：（'T→'T→INT）→'T列表→'T名單	排序使用給定的比較函數(shù)給定列表中。
sum : ^T list → ^T	返回列表中的元素的總和。
sumBy : ('T → ^U) → 'T list → ^U	返回由將所述函數(shù)應(yīng)用于所述列表中的每個元件產(chǎn)生的結(jié)果的總和。
tail : 'T list → 'T list	返回而不第一元件輸入列表。
toArray : 'T list → 'T []	創(chuàng)建一個從給定列表中的數(shù)組。
toSeq : 'T list → seq<'T>	意見給出列表作為序列。
tryFind : ('T → bool) → 'T list → 'T option	返回該給定函數(shù)返回true的第一個元素。如果沒有這樣的元素存在返回無 。
tryFindIndex : ('T → bool) → 'T list → int option	返回滿足給定謂詞列表中的第一個元素的索引。如果沒有這樣的元素存在返回無 。
tryPick : ('T → 'U option) → 'T list → 'U option	適用于給定函數(shù)連續(xù)元素，返回的第一個結(jié)果，其中函數(shù)返回有的為一定的價值。如果沒有這樣的元素存在，那么返回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	結(jié)合了兩個列表成為對的列表。這兩個數(shù)組必須有相等的長度。
zip3 : 'T1 list → 'T2 list → 'T3 list → ('T1 * 'T2 * 'T3) list	將三個列表到三倍的名單。名單必須有平等的長度。

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

例1

該程序顯示遞歸扭轉(zhuǎn)名單 

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)

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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)

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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方法和@運(yùn)算符追加一個列表到另一個

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

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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“折疊”的操作應(yīng)用一個函數(shù)中的每個元素的列表，聚集在一個累加器變量的函數(shù)的結(jié)果，并返回累加器為折疊操作的結(jié)果。

例6

所述List.fold方法適用于從左至右每個元件的功能，同時List.foldBack應(yīng)用一個函數(shù)由右至左的每個元素。

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 ])

當(dāng)你編譯和執(zhí)行程序，它產(chǎn)生以下輸出 

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