F#入门学习（十四）---数组

元组由不同类型的有序的元素构成。
列表由同类型的不可变的元素构成。
序列由由同类型的不可变的元素构成，并且具有无限数据的能力。

以上数据类型默认都是不可变的。

---

今天要学的数组是由相同类型的连续数据元素构成、具有固定大小且小标从0开始，并且可以修改。

---

1. 使用数组常量定义数组

let a1 = [|0;2;4|]//定义一行的时候需要加;

let a2 =  //分开定义的时候不需要
      [|
        0
        2
        4
      |]

结果为：
val a1 : int [] = [|0; 2; 4|]
val a2 : int [] = [|0; 2; 4|]

数组是用[| |]表示的，之间的元素由;分隔

2. 使用双点运算符构成范围表达式定义数组

let a1 = [|1..3..11|]
let a2 = [|1..11|]

结果为：
val a1 : int [] = [|1; 4; 7; 10|]
val a2 : int [] = [|1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11|]

3. 使用for…in生成表达式定义数组

let a = [|for i in 1..10 -> 2*i|]

结果为：
val a : int [] = [|2; 4; 6; 8; 10; 12; 14; 16; 18; 20|]

4. 使用Array.zeroCreate函数创建全为0的数组

let zeroArry : int array = Array.zeroCreate 10

结果为：
val zeroArry : int array = [|0; 0; 0; 0; 0; 0; 0; 0; 0; 0|]

5. 访问数组

//使用数组下标访问数组
let a1 = [|3;6;9|]
let x1 = a1.[0]

//使用数组切片方式访问
let a2 = [|0..10|]
let y1 = a2.[4..6]
let y2 = a2.[..3]
let y3 = a2.[6..]

结果为：
val a1 : int [] = [|3; 6; 9|]
val x1 : int = 3
val a2 : int [] = [|0; 1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]
val y1 : int [] = [|4; 5; 6|]
val y2 : int [] = [|0; 1; 2; 3|]
val y3 : int [] = [|6; 7; 8; 9; 10|]
切片取数组值的时候是不会破坏数组的。

6. 使用运算符<-对数组元素重新赋值

let arry = [|0;2;4|]
arry.[1] <- 8
arry

结果为：
val arry : int [] = [|0; 8; 4|]
val it : int [] = [|0; 8; 4|]

7. 字符串类型string是不可变的数组，只能访问，不能更改
8. 数组有许多静态函数
9. 使用创建数组函数，创建数组

let x1 = Array.empty
let x2 = Array.create 3 5.0
let x3 = Array.init 4 (fun index -> index*index)
let (x4:float array) = Array.zeroCreate 3

结果为：
val x1 : 'a []
val x2 : float [] = [|5.0; 5.0; 5.0|]
val x3 : int [] = [|0; 1; 4; 9|]
val x4 : float array = [|0.0; 0.0; 0.0|]