Go Book / 1 Go Basics / 05 Go容器:数组 Array、切片 Slice、映射 Map

05 Go容器:数组 Array、切片 Slice、映射 Map

一、数组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值类型,当然你也可以用它创建基础数据类型返回指针地址。