一、数组Array
Go语言数组是一个定长的序列，其内部元素一般限定同一类型。数组为切片的底层结构。
//创建数组1：声明后赋值
var arr1 [3]int
arr1[0] = 0
arr1[1] = 1
arr1[2] = 2
//创建数组2：创建并初始化
arr2 := [3]int{1, 3, 5}
//创建数组3：自动计算数组长度
arr3 := [...]int{2, 4, 6, 8, 10}
//len()为内置函数，用来获取数组、切片、字符串、通道（channel）等的长度
var count = len(arr3)
fmt.Printf("类型为%T,值为%v,元素个数为%d\n", arr3, arr3, count)
//类型为[6]int,值为[1 2 3 4 5 6],元素个数为6
//声明一个两行三列的二维数组
var grid [2][3]int
grid[0] = [3]int{1,3,5}
grid[1] = [3]int{2,4,6}
fmt.Println(grid) //[[1 3 5] [2 4 6]]
//遍历数组
for index, value := range arr1 {
fmt.Println(index, " ", value)
}
//0 0
//1 1
//2 2
//3 3
//4 4
二、切片Slice
1.切片声明及初始化
//array[start:end]从数组身上截取下标为[start,end)片段，形成切片
//start代表开始下标，不写默认代表从头开始切
//end代表结束下标（本身不被包含），不写默认截取到末尾
func BaseSlice01() {
//声明并初始化一个数组
var arr = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
//基于数组创建切片
slice1 := arr[2:5]
slice2 := arr[:5]
slice3 := arr[6:]
slice4 := arr[:]
fmt.Printf("arr类型为%T,值为%v\n", arr, arr) //arr类型为[8]int,值为[0 1 2 3 4 5 6 7]
fmt.Printf("slice1类型为%T,值为%v\n", slice1, slice1) //slice1类型为[]int,值为[2 3 4]
fmt.Printf("slice2类型为%T,值为%v\n", slice2, slice2) //slice2类型为[]int,值为[0 1 2 3 4]
fmt.Printf("slice3类型为%T,值为%v\n", slice3, slice3) //slice3类型为[]int,值为[6 7]
fmt.Printf("slice4类型为%T,值为%v\n", slice4, slice4) //slice4类型为[]int,值为[0 1 2 3 4 5 6 7]
}
2.切片追加元素
//向切片中追加元素
func BaseSlice02() {
slice := []int{1, 2, 3, 4}
slice = append(slice, 5, 6) //直接追加多个元素
slice = append(slice, []int{7, 8, 9}...) //追加另一个切片里的元素，需将被追加元素“拍扁”，后面加...即可
fmt.Printf("slice1类型为%T,值为%v,长度为%d,容量为%d\n", slice, slice, len(slice), cap(slice))
////slice1类型为[]int,值为[1 2 3 4 5 6 7 8 9],长度为9,容量为16
//遍历切片
for _, v := range slice {
fmt.Print(v, " ")
}
//1 2 3 4 5 6 7 8 9
}
3.切片容量扩展
//cap(slice)获得切片的容量
//创建之初，容量等于长度
//扩张时，一旦容量无法满足需要，就以翻倍的策略扩容
//注意切片扩容时其栈地址的变化
func BaseSlice03() {
arr := [4]int{1, 2, 3, 4}
fmt.Printf("arr类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", arr, arr, len(arr), cap(arr), &arr)
slice := arr[:]
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 5)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 6)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 7)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 8)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 9)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
slice = append(slice, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
fmt.Printf("slice类型为%T,值为%v,长度为%d,容量为%d,地址为%p\n", slice, slice, len(slice), cap(slice), slice)
}
//arr类型为[4]int,值为[1 2 3 4],长度为4,容量为4,地址为0xc00011e000
//slice类型为[]int,值为[1 2 3 4],长度为4,容量为4,地址为0xc00011e000
//slice类型为[]int,值为[1 2 3 4 5],长度为5,容量为8,地址为0xc000126040
//slice类型为[]int,值为[1 2 3 4 5 6],长度为6,容量为8,地址为0xc000126040
//slice类型为[]int,值为[1 2 3 4 5 6 7],长度为7,容量为8,地址为0xc000126040
//slice类型为[]int,值为[1 2 3 4 5 6 7 8],长度为8,容量为8,地址为0xc000126040
//slice类型为[]int,值为[1 2 3 4 5 6 7 8 9],长度为9,容量为16,地址为0xc0000c0180
//slice类型为[]int,值为[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20],长度为20,容量为32,地址为0xc00012c000
//每次切片扩容都是容量倍增，且其切片头指针地址都发生变化，可见倍增时是另开辟内存并复制
4.切片兼并
/*兼并另一个切片*/
func BaseSlice04() {
slice := []int{1, 2, 3, 4}
fmt.Printf("slice1类型为%T,值为%v,长度为%d,容量为%d\n", slice, slice, len(slice), cap(slice))
sli := []int{7, 8, 9}
slice = append(slice, sli...) //兼并时注意“拍扁”
fmt.Printf("slice1类型为%T,值为%v,长度为%d,容量为%d\n", slice, slice, len(slice), cap(slice))
}
//slice1类型为[]int,值为[1 2 3 4],长度为4,容量为4
//slice1类型为[]int,值为[1 2 3 4 7 8 9],长度为7,容量为8
5.使用make()函数创建切片
/*创建指定长度和容量的切片*/
func BaseSlice05() {
//创建空切片
slice1 := make([]int, 0)
fmt.Printf("slice1类型为%T,值为%v,长度为%d,容量为%d\n", slice1, slice1, len(slice1), cap(slice1))
//slice1类型为[]int,值为[],长度为0,容量为0
//创建空切片，但指定容量
slice2 := make([]int, 0, 5)
fmt.Printf("slice2类型为%T,值为%v,长度为%d,容量为%d\n", slice2, slice2, len(slice2), cap(slice2))
//slice2类型为[]int,值为[],长度为0,容量为5
//创建长度为3容量为5的切片，默认长度的元素都初始化为零值
slice3 := make([]int, 3, 5)
fmt.Printf("slice3类型为%T,值为%v,长度为%d,容量为%d\n", slice3, slice3, len(slice3), cap(slice3))
//slice3类型为[]int,值为[0 0 0],长度为3,容量为5
//创建长度为5的切片，默认长度的元素都初始化为零值，未指定容量时容量值等于长度值
slice4 := make([]int, 5)
fmt.Printf("slice4类型为%T,值为%v,长度为%d,容量为%d\n", slice4, slice4, len(slice4), cap(slice4))
//slice4类型为[]int,值为[0 0 0 0 0],长度为5,容量为5
}
6.删除切片元素
go没有内置的切片删除函数，所以删除元素需要遍历切片
//删除切片元素
func RmSliceElement(slice []interface{}, index int) []interface{} {
if index > len(slice)-1 {
panic("index out of range")
}
for _, v := range slice {
//如果是最后一个元素
if index == len(slice)-1 {
return slice[:index]
}
//如果是中间元素
if v == slice[index] {
return append(slice[:index], slice[index+1:]...)
}
}
return nil
}
三、映射Map
1.map的创建
//创建并初始化
m1 := map[string]string{
"name": "fun",
"age": "18",
"gender": "male",
}
//创建一个长度为5的空map,已分配内存
m2 := make(map[string]int,5)
//只声明一个map，未分配内存
var m3 map[string]int
fmt.Printf("m1:%v,地址为%p\n", m1,m1)
fmt.Printf("m2:%v,地址为%p\n", m2,m2)
fmt.Printf("m3:%v,地址为%p\n", m3,m3)
//m1:map[age:18 gender:male name:fun],地址为0xc00008e480
//m2:map[],地址为0xc00008e4b0
//m3:map[],地址为0x0
2.map的遍历及访问值
//遍历
m := map[string]string{
"name": "fun",
"age": "18",
"gender": "male",
}
for key, val := range m {
fmt.Printf("Key:%s,Value:%v\n", key, val)
}
//Key:name,Value:fun
//Key:age,Value:18
//Key:gender,Value:male
//访问一个键值
name := m["name"]
fmt.Printf("name:%v\n", name)
//name:fun
//访问一个不存在的键
names := m["names"]
fmt.Printf("names:%v\n", names)
//names:
//带校验的访问
if a, ok := m["name"]; !ok {
fmt.Println("key is not exist!")
} else {
fmt.Println(a)
}
3.map删除元素
delete()为内置函数，只对map有效
func BaseMap03() {
m := map[string]string{
"name": "fun",
"age": "18",
"gender": "male",
}
fmt.Printf("m：%v\n", m)
delete(m, "age")
fmt.Printf("m：%v\n", m)
}
//m：map[age:18 gender:male name:fun]
//m：map[gender:male name:fun]
4.多维map的使用
//多维map的使用
func BaseMap04() {
//声明二维map的结构
var ms = make(map[string]map[string]int, 3)
fmt.Printf("ms:Type:%T, Value：%v, Len:%d, Address:%p\n", ms, ms, len(ms), ms)
//为二维map的内部初始化
ms["a"] = make(map[string]int, 4)
ms["b"] = make(map[string]int, 5)
ms["c"] = make(map[string]int, 6)
fmt.Printf("ms:Type:%T, Value：%v, Len:%d, Address:%p\n", ms, ms, len(ms), ms)
ms["d"] = make(map[string]int, 7)
fmt.Printf("ms:Type:%T, Value：%v, Len:%d, Address:%p\n", ms, ms, len(ms), ms)
//赋值：只有二维数组内部初始化后才能赋值
//否则报panic: assignment to entry in nil map
ms["a"]["aa"] = 1
ms["a"]["bb"] = 2
ms["a"]["cc"] = 3
fmt.Printf("ms:Type:%T, Value：%v, Len:%d, Address:%p\n", ms, ms, len(ms), ms)
//[1]ms:Type:map[string]map[string]int, Value：map[], Len:0, Address:0xc000104300
//[2]ms:Type:map[string]map[string]int, Value：map[a:map[] b:map[] c:map[]], Len:3, Address:0xc000104300
//[3]ms:Type:map[string]map[string]int, Value：map[a:map[] b:map[] c:map[] d:map[]], Len:4, Address:0xc000104300
//[4]ms:Type:map[string]map[string]int, Value：map[a:map[aa:1 bb:2 cc:3] b:map[] c:map[] d:map[]], Len:4, Address:0xc000104300
}
四、关于make()和new()函数
1.make()
Go为创建切片slice、映射map、通道chan内建一个函数，即make()。
用法：
func make(Type, size IntegerType) Type
根据官方文档：
- 参数一为类型，非值，返回类型与其参数相同
- 参数二不同类型传参不同
切片：size指定了其长度。该切片的容量等于其长度。切片支持第二个整数实参可用来指定不同的容量；它必须不小于其长度，因此 make([]int, 0, 10) 会分配一个长度为0，容量为10的切片。
映射：初始分配的创建取决于size，但产生的映射长度为0。size可以省略，这种情况下就会分配一个小的起始大小。
通道：通道的缓存根据指定的缓存容量初始化。若 size为零或被省略，该信道即为无缓存的。
2.new()
用法：
func new(Type) *Type
内建函数new分配内存。其第一个实参为类型，而非值。其返回值为指向该类型的新分配的零值的指针。
3.两个函数的区别
- make()是专门用来创建切片、映射、通道的，为其分配内存并初始化零值，返回的切片、映射、通道天生就是指针地址。
- new()一般是为创建除内置引用类型外的其他任意类型分配内存的，但不会初始化数据，只会把内存置零，返回的是*T指针地址。一般用于创建array或struct值类型，当然你也可以用它创建基础数据类型返回指针地址。
