08.Go 数组

复合数据类型是包含各种形式的存储和处理数据的功能，可以把它看成一个“容器”。Go语言的复合数据类型包括数组、切片、映射及列表等。

Go语言的4种复合数据类型可以让开发者管理集合数据，这4种数据类型也是Go语言核心的一部分，在标准库中被广泛使用。

1、数组的声明

数组是具有相同类型的一组已经编号且长度固定的数据项序列，这个序列可以是有序的也可以是无序的，组成数组的各个变量称为数组的元素。数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为0，第二个索引为1，以此类推。

数组元素的类型可以是任意的原始类型，如int、string或者自定义类型。数组长度必须是一个非负整数的常量（或常量表达式），数组长度也是数组类型的一部分，所以，[20]int和[100]int不是同一种类型。

数组的声明：var 数组变量名 [元素数量]Type

• （1）数组变量名：数组声明及使用时的变量名。
• （2）元素数量：数组的元素数量，可以是一个表达式，但最终通过编译器计算的结果必须是整型数值，元素数量不能含有到运行时才能确认大小的数值。
• （3）Type：可以是任意基本类型，包括数组本身，类型为数组本身时，可以实现多维数组。

//声明一个包含5个元素的整型数组
var array [5]int

//声明一个包含3个元素的字符串数组
var team [3]string

注意：数组一旦声明，它存储的数据类型和数组长度就都不能修改了。所以，如果需要存储更多的元素，必须先创建一个更长的数组，然后把原来数组中的值复制到新数组中。

数组的特点：

• （1）数组创建完后长度就固定了，不可以再添加元素。
• （2）数组是值类型，数组赋值或作为函数参数都是值复制。
• （3）数组长度是数组类型的组成部分，例如，[10]int和[20]int表示不同的类型。
• （4）可以根据数组创建切片。

2、数组的初始化

Go语言在声明变量时，都是使用相应类型的零值来初始化变量的，数组也一样。数组初始化时，其每个元素都被初始化为对应类型的零值。例如，上面的整型数组中，每个元素都被初始化为0（整型的零值）。

数组的初始化有以下几种情况：

（1）使用数组字面量可以快速创建并初始化数组，数组字面量可以声明数组中元素的数量，并指定每个元素的值：

// 用具体值初始化每个元素
a := [3]int {1,2,3}

（2）当数组的长度不确定时，可以使用“…”来代替数组的长度，Go语言会根据初始化时数组元素的数量来确定该数组的长度：

// 用具体值初始化每个元素，长度由初始化的值来确定
a := […]int {1,2,3}

（3）当知道数组的总长度时，还可以给特定的下标指定具体的值。通过索引值进行初始化，没有初始化元素时使用类型默认值：

//用具体值初始化索引为1和2的元素，其余元素保持类型默认值
a := [3]int {1:1,2:3}

（4）当不确定数组的总长度时，同样也可以给特定的下标指定具体的值。通过索引值进行初始化，数组长度由最后一个索引值确定，没有指定索引的元素被初始化为类型的零值：

//用具体值初始化索引为1和2的元素，长度由最后一个索引值来确定，其余元素保持零值
a := […]in
t {1:1,2:3}

3、数组的遍历

访问数组元素：元素的数目（长度或者数组大小）必须是固定的并且在声明数组时就指定的，数组长度最大为2GB：

func main() {
	var arr [10]int
	var i int
	// 初始化数组
	for i = 0; i < 10; i++ {
		arr[i] = i + 100
	}
	// 输出每个数组元素的值
	for i = 0; i < 10; i++ {
		fmt.Printf("元素[%d] = %d\n", i, arr[i])
	}
}

4、数组元素的修改

数组是效率很高的数据结构，因为数组在内存分配中是连续的，要访问数组中的某个单独元素，需要使用“[]”运算符：

//声明一个包含5个元素的整型数组，用具体值初始化每个元素
a := [5]int {1,2,3,4,5}

//修改索引为2的元素的值
a[2] = 8

数组的值也可以是指针。例如，声明一个所有元素都是指针的数组，然后使用“*”运算符访问元素指针所指向的值。

// 声明一个包含5个元素的整型数组
// 用整型指针初始化索引为0和1的数组元素
a := [5]*int{0: new(int), 1: new(int)}

// 为索引为0和1的元素赋值
*a[0] = 1
*a[1] = 2

数组作为变量类型，包括数组长度和每个元素的类型两个部分。只有这两部分都相同的数组才是类型相同的数组，才能相互赋值：

// 声明一个包含4个元素的字符串数组
var a1 [4]string

// 声明第二个包含5个元素的字符串数组
// 用颜色初始化数组
a2 := [5]string{"red", "green", "yellow", "black", "white"}

a1 = a2 //编译报错：Cannot use 'a2' (type [5]string) as the type [4]string
fmt.Println(a1)

如果赋值数组指针，只会赋值指针的值，而不会赋值指针所指向的值：

// 声明第一个包含3个元素的指向字符串的指针数组
var a1 [3]*string
// 声明第二个包含3个元素的指向字符串的指针数组
// 使用字符串指针初始化数组
a2 := [3]*string{new(string), new(string), new(string)}
// 使用颜色为每个元素赋值
*a2[0] = "red"
*a2[1] = "blue"
*a2[2] = "green"
// 将a2赋给a1
a1 = a2
fmt.Println(a1)
fmt.Println(*a1[0], *a1[1], *a1[2])

5、多维数组

数组本身只有一个维度，但是可以组合多个数组来创建多维数组。

Go语言中允许使用多维数组，因为数组属于值类型，所以，多维数组的所有维度都会在创建时自动初始化零值，多维数组尤其适合管理具有父子关系或者与坐标系相关联的数据。

声明多维数组的语法格式如下：var array_name [size1][size2]…[sizen] array_type

//声明一个二维整型数组,两个维度的长度分别是 4 和 2
var array [4][2]int

//使用数组字面量来声明并初始化一个二维整型数组
array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}

//声明并初始化数组中索引为 1 和 3 的元素
array = [4][2]int{1: {20, 21}, 3: {40, 41}}

//声明并初始化数组中指定的元素
array = [4][2]int{1: {0: 20},3: {1: 41}}

此时为了访问单个元素，需要组合使用“[]”运算符:

//声明一个 2×2 的二维整型数组
var array [2][2]int

//设置每个元素的整型值
array[0][0] = 10
array[0][1] = 20
array[1][0] = 30
array[1][1] = 4

与一维数组相同，只要类型一致，就可以将多维数组互相赋值。多维数组的类型包括两个部分，即每一维度的长度和存储在元素中数据的类型：

//声明两个二维整型数组
var array1 [2][2]int
var array2 [2][2]int

//为array2的每个元素赋值
array2[0][0]= 10
array2[0][1]= 20
array2[1][0]= 30
array2[1][1]= 40

//将 array2 的值赋值给array1
array1 = array2

数组中的每个元素都是一个单独的值，所以，可以独立复制某个维度：

//将 array1 的索引为 1 的维度复制到一个同类型的新数组中
var array3 [2]int = array1[1]

//将数组中指定的整型值复制到新的整型变量中
var value int = array1[1][0]