Lists

在F＃中，列表是有序的，不可变的相同类型的元素系列。 它在某种程度上等同于链表数据结构。

F＃模块Microsoft.FSharp.Collections.List,对列表具有常见操作。 但是，F＃会自动导入此模块，并使每个F＃应用程序都可以访问它。

创建和初始化列表

以下是创建列表的各种方法 -

• 使用列表literals 。

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

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

• 使用一些名为List Comprehensions syntactic constructs 。

列出文字

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

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

The cons (::) Operator

使用此方法，您可以使用::运算符通过在现有列表中添加或使用它来添加一些值。 例如 -

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

[]表示一个空列表。

列出init方法

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

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

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

例如，

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

这里，索引函数生成列表。

列表理解

列表推导是用于生成列表的特殊语法结构。

F＃list comprehension语法有两种形式 - 范围和生成器。

范围有结构 - [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) ]

当yield关键字将单个值推送到列表中时，关键字yield!,将一组值推送到列表中。

以下函数演示了上述方法 -

例子 (Example)

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

列表数据类型的属性

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

以下示例显示了这些属性的用法 -

例子 (Example)

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

列表中的基本运算符

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

以下示例演示了上述功能的用途 -

例子1 (Example 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 (Example 2)

该程序显示使用List.filter方法过滤列表 -

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

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

例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.