Golang 教程7——切片、映射

Golang 教程6——切片、映射

注意，该文档只适合有编程基础的同学，这里的go教程只给出有区别的知识点

1、数组有特定的用处， 但是有些呆板（数组的长度固定不变）， 所以在Go语言的代码里不是特别常见。相对的，切片随处可见，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供强大的能力和便捷。

2、切片（slice）是对数组一个连续片段的引用， 所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终止索引标识的一些项的子集。

切片有3个字段的数据结构： 一个是指向底层数组的指针， 一个是数组的长度， 一个是切片的容量。

1.1 main文件

package main

import (
	"fmt"
)

func main() {
	var arr = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	// 1、定义方式1： 切片定义在数组之上
	// 定义一个切片，名字为slice，类型为int，[]动态变化的数组长度不写, arr是原数组
	// [2:5]切片， 2是起始位置，5是结束位置（不包括5） ->[2, 5)
	slice := arr[2:5]
	// 打印切片
    fmt.Println("slice:", slice)
	// 打印切片长度
	fmt.Println(len(slice))
	// 打印切片容量： 容量可以动态变化
	fmt.Println(cap(slice))
	
	//通过切片对数据中的元素进行改变
	slice[0] = 100
	slice[1] = 200
	fmt.Println(arr)
	fmt.Println(slice)

	//2、定义方式2：通过内置函数make创建切片 make(切片的类型，切片长度， 切片的容量)
	//make会在底层创建一个数组，但是这个数组在外界是不可见的。
	slice1 := make([]int, 5, 10)
	slice1[0] = 1
	slice1[1] = 2
	fmt.Println(slice1)

	//3、定义方式3：定义一个切片， 直接就指定具体数组，使用原理类似make方式
	slice2 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("slice2: ", slice2)

	fmt.Println("---------------------------------------------------------")
}

/* 
切片在定义之后不能直接使用，需要让其引用到一个数组，或者make一个空间供切片使用
切片的使用不能越界
简写方式
1) var slice = arr[0: end] --> var slice = arr[: end]
2) var slice = arr[start:len(arr)] --> var slice = arr[start:]
3) var slice = arr[0:len(arr)] --> var slice = arr[:]
切片后可以继续切片

var slice1 [6]int = [6]int{1, 2, 3, 4, 5, 6}
var slice2 = slice1[2:5] 注意，下标都是从0开始的

*/

1.2 输出结果

(base) PS E:\Goproject\src\gocode\testproject01> go run ./main/main.go
[3 4 5]
3
8
[1 2 100 200 5 6 7 8 9 10]
[100 200 5]
[1 2 0 0 0]
slice2:  [1 2 3 4 5 6 7 8 9 10]

1.3 切片的操作

func main () {
    slice2 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	//4、切片的遍历
	for i, val := range slice2 {
		fmt.Println(i, val)
	}

	// 切片增加元素
	// 底层原理：
	// 底层追加元素的时候，会创建一个新的底层数组，然后把原来的数组拷贝到新的数组中，
	// 然后把新的数组赋值给slice3，然后把新的slice3返回
	slice3 := append(slice2, 11, 12, 13, 14, 15)
	fmt.Println(slice3)
	// 往往我们在使用追加的时候其实想要做的效果是给slice追加：
	slice2 = append(slice2, 11, 12, 13, 14, 15)

	//可以将切片追加给切片
	slice4 := append(slice2, slice3...)
	fmt.Println("slice4:", slice4)

	//切片删除元素 s = append(s[:indexToDelete], s[indexToDelete+1:]...)
	slice5 := append(slice2[:3], slice2[5:]...) //删除下表为3、4的元素
	fmt.Println("slice5:", slice5)

	//切片拷贝
	var newArr []int = make([]int, 20)
	copy(newArr, slice2)
	fmt.Println("newArr:", newArr)
}

1.4 输出结果

(base) PS E:\Goproject\src\gocode\testproject01> go run ./main/main.go
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
slice4: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
slice5: [1 2 3 6 7 8 9 10 11 12 13 14 15]
newArr: [1 2 3 6 7 8 9 10 11 12 13 14 15 14 15 0 0 0 0 0]

2. 映射

2.1 映射的定义

func main() {
	//方式1： 定义map变量：
	var m map[int] string
	// 只声明map变量，没有初始化，程序不会分配空间，所以为nil
	// 必须通过make函数进行初始化， 才会分配空间
	fmt.Println(m)
	//key的值不能重复，否则会覆盖， value可以重复
	// m[key] = value
	m = make(map[int] string, 10)
	m[1] = "2009年"
	m[1] = "2029年"
	m[2] = "2019年"
	m[3] = "2019年"
	fmt.Println("方式1:", m)

	//方式2： 定义map变量：
	m2 := make(map[int] string)
	m2[1] = "2009年"
	m2[1] = "2029年"
	m2[2] = "2019年"
	m2[3] = "2019年"
	fmt.Println("方式2:", m2)

	//方式3： 直接定义map变量：
	m3 := map[int] string{
		1: "2009年",
		2: "2019年",
		3: "2019年",
	}
	fmt.Println("方式3:", m3)

}

2.2 输出结果

(base) PS E:\Goproject\src\gocode\testproject01> go run ./main/main.go
map[]
方式1: map[1:2029年 2:2019年 3:2019年]
方式2: map[1:2029年 2:2019年 3:2019年]
方式3: map[1:2009年 2:2019年 3:2019年]

2.3 映射的基本操作

func main() {
	m3 := map[int] string{
		1: "2009年",
		2: "2019年",
		3: "2019年",
	}
	fmt.Println(m3)

	//1、删除操作
	delete(m3, 2)
	fmt.Println("删除key为2之后:", m3)

	//2、清空操作，没有专门的办法清空，直接重新声明一个map即可
	// m3  = make(map[int] string, 10)
	// fmt.Println(m3)

	//3、查找, value 表示值， flag 表示是否存在
	value, flag := m3[2]
	fmt.Println("当前map", m3)
	fmt.Println("查找key为2的value:", value, flag)

	//4、获取map的长度
	fmt.Println("当前map的长度:", len(m3))

	//5、遍历map
	for k, v := range m3 {
		fmt.Println("key:", k, "value:", v)
	}
}

2.4 输出结果

(base) PS E:\Goproject\src\gocode\testproject01> go run ./main/main.go
map[1:2009年 2:2019年 3:2019年]
删除key为2之后: map[1:2009年 3:2019年]
当前map map[1:2009年 3:2019年]
查找key为2的value:  false
当前map的长度: 2
key: 3 value: 2019年
key: 1 value: 2009年