Go基础-006-01 复合数据类型 概述&数组

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 注意：需要用括号包一下，否则执行顺序是先取数组元素
}