Golang学习（10）：数组、切片、集合的创建

数组 arr (指定元素个数)

相关信息

数组中的元素并不限制值的类型，但要求所有元素均为相同的类型

Go语言中声明数组的一般格式为：

go
var array_name [quantity]Type

array_name表示数组名
quantity表示数组元素个数
Type表示元素类型。

go
// 声明一个长度为 4 ，元素类型为 int 的数组
var  a [4]int

// 给第 3 个元素赋值
a[2] = 5

go
// 默认情况下 数组中每个元素初始化时候 根据元素的类型 对应该数据类型的零值
// [1,2,0]
arr1 := [3]int{1,2}
fmt.Println(arr1[2]) //下标为2的元素没有, 默认取int类型的零值

// 数组创建方式1 创建时 直接将值赋到数组里
// [1,2,3,4,0]
arr2 := [5]int{1,2,3,4}    //值可以少 默认是0  但是不能超过定长

// 在指定位置上存储值
// [0,2,0,5,0]
arr3 := [5]int{1:2,3:5} //在下标为1的位置存储2，在下标为3的位置存储5

go
//长度可以用...代替  根据数值长度程序自动填充数值的大小
arr4 :=  [...]int{1,2,3,4}

//简短声明方式
arr5 := [...]int{2:3,6:3}//在固定位置存储固定的值

注意

数组的索引从0开始，因此索引的取值范围应该是从0至数组元素个数减1为止。如本例则为0、1、2、3。

超出范围的赋值和取值将引发下标越界错误，导致程序出错。对某一索引位置的元素重复赋值将导致旧值被新值替换。

多维数组

txt
// 语法
arr:=[总共多少个一维数组][每个一维数组的长度]数据类型{{默认值}，{}，{}} 

// 示例
arr:=[3][4]int{{1,2,3,4},{},{}}

go
//声明一个二维数组
var arr [3][8]int

//给二维数组赋值
arr[0]=[8]int{1,2,3,4,5,6,7,8}

// [[1 2 3 4 5 6 7 8] [0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0]]
fmt.Println(arr) 

// [[1 2 3 4 5 6 7 8] [0 0 0 9 0 0 0 0] [0 0 0 0 0 0 0 0]]
arr[1][3]=9
fmt.Println(arr)

切片 slice （不定元素个数）

如果使用数组来存放结果的话，很容易引发下标越界错误。和数组相对，Go语言还提供了一种专门存放不定元素个数的数据结构——切片。

在实际项目中，切片的使用其实更为广泛。

例如：当用户发起搜索，搜索的结果个数往往会根据搜索关键字的不同而发生变化。在不确定总数的前提下，使用数组显然是不合适的。

切片的扩充 (append)

与数组不同，为切片赋值可以理解为扩充，需要使用 append 关键词一个个添加

使用格式如下：

go
slice_name2 = append(slice_name1, value)

slice_name表示已声明的切片变量名
value表示具体的数据值

注意

append()函数本身并不会改变原有切片，只是将切片“扩容”后的结果作为函数返回值。

因此，需要将“扩容”后的结果再次（即函数返回值）赋值给slice_name，才能真正使slice_name发生改变。

go
// 声明一个切片
var a []int

// 扩充切片 a，添加一个为 2 的值
a = append(a, 2)

// 将扩容结果赋给 b
b = append(a, 2)

go
//使用make函数创建切片
s1:=make([]int,0,5)
s2:=make([]int,0,3)

//添加一组切片到另一切片中
//...表示将另一个切片数组完整加入到当前切片中
s2=append(s2,s1...)

切片扩充的原理

go
s1 := make([]int, 0, 3)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
s1 = append(s1, 1, 2)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
s1 = append(s1, 3, 4, 5)
fmt.Printf("地址%p,长度%d,容量%d\n", s1, len(s1), cap(s1))
    
    
//地址0xc000010540,长度0,容量3
//地址0xc000010540,长度2,容量3
//地址0xc00000e4b0,长度5,容量6

集合 map

集合的元素都是由若干“键-值对”数据构成的。

所谓“键”，相当于“唯一ID”；“值”，相当于单条数据，键不允许重复。

Go语言中声明集合的一般格式为：


var map_name = make(map[key_type]value_type)

map_name 表示集合的变量名
key_type 表示键的类型
value_type 表示值的类型。

获取元素个数

Go语言内置了获取容器内元素个数的函数，这个函数对数组、切片和集合都有效，用法相同

go
// 获取实际存储的数据量
len(variable)

// 容器中能够存储的最大数据量  因为数组是定长的 所以长度和容量是相同的
cap(variable)

// 调用后，函数将返回元素个数，返回值的类型是int

go
var a [5]int

// 0
len(a)
// 5
cap(a)

a = append(a, 1)
a = append(a, 3)
a = append(a, 5)
a = append(a, 7)

// 4
len(a)

修改元素

修改数组、切片和集合中的值，方法与赋值相同；
获取数组或切片的值，格式为variable[index]。
- variable表示数组或切片的变量名
- index表示索引值。
获取集合的值，格式为variable[key_value]。
- variable表示集合的变量名
- key_value表示键的值。

go
var a[3]int
// 修改数组
a[0] = 5


var b[]int
b = append(b, 1)
b = append(b, 3)
// 修改切片
b[1] = 5


var c = make(map[int]string)
// 修改集合
c[1] = "5"

遍历

除了for循环外，Go语言还提供了range关键字。与for结合，也可以实现循环遍历。

for-range结构同样适用于数组和切片

其使用格式如下：

go
for index, value := range variable {
    // 循环体
}

index表示索引或键的值
value表示元素的值
variable表示数组、切片或集合变量
由大括号包裹的部分是循环体，可以使用index和value变量

go
var c = make(map[int]string)
// 修改集合
c[1] = "5"
c[2] = "好"
c[3] = "a"

for key, value := range c {
    fmt.Print("键：", key, "值:", value)
}

目录