0.复合数据类型概述
高级类型，复杂类型。 结构比较复杂，一个数据可能会存储多个值，是一种集合。
数组 array，切片 slice，映射表 map，结构体 struct
1.类型
数组:特定数量的同类型元素的集合。 内存中的表示，一段连续的内存空间。 要点:
- 类型相同
- 长度固定
语法为:
[长度]元素类型
[n]T
其中长度，应该是整型数据，元素类型已知的各种类型，甚至还是数组都可以。
典型的定义语法如下:
var a2 [3]int
fmt.Println(a2) // [0 0 0]
数组类型定义时，若没有指定其元素值，则每个元素使用类型对应的零值进行初始化。
数组也有字面量语法，也可以通过类型推导完成变量定义。
2.字面量
字面量为
[n]T{元素 0, 元素 1... 元素 n-1}
因此，支持使用使用字面量来定义数组变量:
a1 := [3]int{42,42,42}
fmt.Println(a1) // [42 42 42]
该字面量，支持的语法很灵活，支持:
- [n]T{元素0,元素1...元素n-1}，指定长度，给出每个元素
- [...]T{元素0,元素1...元素n-1}，给定每个元素，推测长度，长度使用...占位
- [n]T{元素 0, 元素 1... }，指定长度，但仅给定部分元素，前面的元素会被指定值 初始化，后边的元素使用类型零值初始化。
- [n]T{0:元素0,5:元素5}，指定长度，通过元素索引给定部分元素值，使用特定值 初始化指定的元素
- [...]T{0:元素0,5:元素5}，通过最大索引推测长度，通过元素索引给定部分元素值， 使用特定值初始化指定的元素
func main() {
a1 := [3]int{1,2,3}
fmt.Println(a1) // [1 2 3]
a2 := [3]int{1,3}
fmt.Println(a2) // [1 3 0]
a3 := [3]int{0:1,2:1}
fmt.Println(a3) // [1 0 1]
a4 := [...]int{1,2,3}
fmt.Println(a4) // [1 2 3]
a5 := [...]int{0:1, 5:1}
fmt.Println(a5) // [1 0 0 0 0 1]
}
3.操作
1) 索引操作
数组中每个值，称之为元素，element。
每个元素，使用索引 index 表示其在数组中的位置。由 0 开始，递增，最后一个元素的 索引为（长度-1）
数组也描述成 index-value 对(索引-值对)的集合。 通过运算符[]可以访问到对应的索引元素。
演示:
a1 := [3]int{1,2,3}
fmt.Println(a1[0]) // 1
注意：数组索引越界会编译错!
2) len()，计算元素个数
数组长度。(数组长度不可改变!)
代码演示：
a1 := [3]int{1,2,3}
fmt.Println(len(a1)) // 3
3) 支持比较是否相等 ==
可以通过 关系运算符 ==，(或者 !=)来判断两个数组是否相等(或不相等)。
数组相等，意味着两个数组的长度，元素类型，及每个对应元素都要相等。
代码演示:
fmt.Println([3]int{} == [3]int{}) // true
fmt.Println([3]int{1,2,3} == [3]int{1,2,3}) // true
fmt.Println([3]int{1,2,3} == [3]int{1,3,3}) // false
3) for range 遍历
遍历，依次获取每个元素。
遍历数组结构，使用特定的语法 for range 来实现。
语法为:
for i, v := range arr {
}
语法说明：
arr ：待遍历的数组
i ： 索引变量，每个元素的索引，每次获取一个元素的索引，获取数组长度次。得到元素
时被赋值，变量名任意。
v ：值变量，每个元素的值，每次获取一个元素的值，获取数组长度次。得到元素时被 赋值，变量名任意。
代码演示：
func main() {
a1 := [4]string{"a", "b", "c", "d"}
for i,v := range a1 {
fmt.Println(i, v)
}
}
for range 有两个变体，用于仅仅获取索引或者是值，语法如下:
- 单个变量，表示获取索引。
- 使用匿名变量占位索引，用值变量获取值。
代码演示：
func main() {
a1 := [4]string{"a", "b", "c", "d"}
// 仅获取索引
for i := range a1 {
fmt.Println(i)
}
// 仅获取值
for _,v := range a1 {
fmt.Println(v)
}
}
4.数组嵌套（多维数组）
数组类型的声明，[n]T，T 可以是任意的类型。 若数组元素的类型为其他数组类型，则该数组是一个嵌套数组，也叫多维数组。 演示:
func main() {
a2 := [4][4]int{}
fmt.Println(a2)
// 输出 [[0 0 0 0] [0 0 0 0] [0 0 0 0] [0 0 0 0]]
a2 := [4][4]int{
[4]int{1,2,3,4},
[4]int{1},
[4]int{1},
[4]int{1},
} // 定义时，数组值可以省类型
fmt.Println(a2)
// 输出：[[1 2 3 4] [1 0 0 0] [1 0 0 0] [1 0 0 0]]
}
注意：本质上来说，没有多维的概念，仅仅是元素类型为数组而已。
嵌套数组如果需要遍历内部的每个元素，会使用嵌套的 for range 结构。
5.数组与指针
数组类型的指针，在获取元素值时，可以自解引用。
代码示例：
func main() {
arr := [4]int{1,2,3,4}
arrP := &arr
fmt.Println(arr[0]) // 1
fmt.Println((*arrP)[0]) // 1 注意：需要用括号包一下，否则执行顺序是先取数组元素
}
