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:20292:20193:2019]
方式2: map[1:20292:20193:2019]
方式3: map[1:20092:20193: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:20092:20193:2019]
删除key为2之后: map[1:20093:2019]
当前map map[1:20093:2019]
查找key为2的value:  false
当前map的长度: 2
key: 3 value: 2019年
key: 1 value: 2009

你可能感兴趣的:(golang)