Golang 学习笔记（04）—— array, slice, map

介绍

Array 是值类型，Slice 和 Map 是引用类型。他们是有很大区别的，尤其是在参数传递的时候。 另外，Slice 和 Map 的变量 仅仅声明是不行的，必须还要分配空间（也就是初始化，initialization） 才可以使用。 第三，Slice 和 Map 这些引用变量 的 内存分配，不需要你操心，因为 golang 是存在 gc 机制的（垃圾回收机制） array

顾名思义，就是数组的意思，固定长度的数组，使用前必须确定数组的长度。值类型的，即将一个数组赋值给另外一个数组的时候，实际上就是将整个数组拷贝一份。

验证是值类型的

func main(){ var a = [5]int{1,2,3,4,5} e := a e[2] = 10 fmt.Printf("a:%v\n", a) fmt.Printf("e:%v\n", e) } [图片上传失败...(image-51a319-1513159622174)]

声明

数组的声明如下：（这里就是定义，给数据存储分配了空间）

var arrayName [arraySize] dataType 例如：

var a [10]int var str [10]string 如果数组定义好之后， 没有给数组元素指定值，那么所有元素被自动初始化为零值。

func main(){ var a [10]int var str [10]string fmt.Printf("a:%v\n", a) fmt.Printf("str:%v", str) } [图片上传失败...(image-938420-1513159622174)]

数组初始化

func main(){ //定义数组的时候，直接初始化 var a = [5]int{1,2,3,4,5} //初始化部分元素，其余归零 var b = [10]int {1,2,3,4,5} //由初始化列表确定数组长度，不可省略标识符"..."否则会变成切片， var c = [...]int {1,2,3} //按照指定下标来初始化 var d = [10]int{2:5, 7:10} fmt.Printf("a:%v\n", a) fmt.Printf("b:%v\n", b) fmt.Printf("c:%v\n", c) fmt.Printf("d:%v\n", d) } [图片上传失败...(image-2d0124-1513159622174)]

数组的操作

对于数组的赋值和取值都可以用下标来实现，如：

func main(){ var a [5]int a[2] = 10 b := a[2] fmt.Println("a: ", a) fmt.Println("set a[2]: ", a[2]) fmt.Println("get a[2]: ", b) } [图片上传失败...(image-37ab69-1513159622174)]

另外可以通过len方法获取数组的长度

a := [10]int len := len(a) 遍历数组

func main(){ a := [5]int{1,2,3,4,5} //下标遍历数组 for i := 0; i < len(a); i++{ fmt.Printf("a[%d] = %d\n", i, a[i]) } fmt.Println("") // range关键字遍历 for i, v := range a{ fmt.Printf("a[%d] = %d\n", i, v) } } [图片上传失败...(image-908ce0-1513159622174)]

Slice

slice是引用类型，有点像指向数组的指针，slice的声明与数组的声明类似，但是不需要指定长度。其中，slice有两个重要属性，一个是len（长度），另一个是cap(容量)。长度是只当前slice中数据的实际长度，容量是指当前slice的最大长度。

验证是引用类型的

func main(){ s1 := []int{1,2,3,4,5} s2 := s1 s2[2] = 10 fmt.Println("s1: ", s1) fmt.Println("s2: ", s2) } [图片上传失败...(image-be53f6-1513159622174)]

声明

slice的声明如下（没有分配内存）：

var sliceName [] dataType 另外还有三种创建slice的方式，但这是方式是已经分配内存了的。 三种创建方式： 基于底层数组创建，直接创建，或者 make() 函数创建

基于底层数组创建 func main(){ a := [5]int{1,2,3,4,5} //数组 sa1 := a[1:4] //基于数组创建，数据为a[1]，a[2],a[3],不包括a[4] sa2 := a[:] //引用全部元素 fmt.Println("a: ",a) fmt.Println("sa1: ",sa1) fmt.Println("sa2: ",sa2) } [图片上传失败...(image-e9e4ff-1513159622174)]

直接创建 slice 在声明的时候，直接初始化。 var slice1 = []int {1 ,2, 3, 4, 5} make() 函数创建 slice var slice1 = make([]int, 5) //长度和容量都是 5 var slice2 = make([]int, 5, 10) //容量是5. slice操作

Slice 中的切片的元素，可以动态的添加和删除，所以操作起来要比数组更加方便

增加元素

采用内建函数 append() 向切片尾部，增加新的元素。 先上代码

func main(){ s1 := make([]int, 3, 6) //创建一个len=3,cap=6的切片 fmt.Printf("s1: len = %d cap = %d %v\n", len(s1), cap(s1), s1)

s2 := append(s1, 1, 2, 3)
fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)

s1[0] = 5
s2[1] = 20
fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)

s3 := append(s1, 1,2,3,4,5)
fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)
fmt.Printf("s3: len = %d   cap = %d   %v\n", len(s3), cap(s3), s3)

s1[0] = 100
fmt.Printf("s1: len = %d   cap = %d   %v\n", len(s1), cap(s1), s1)
fmt.Printf("s2: len = %d   cap = %d   %v\n", len(s2), cap(s2), s2)
fmt.Printf("s3: len = %d   cap = %d   %v\n", len(s3), cap(s3), s3)
复制代码

} [图片上传失败...(image-bc6b97-1513159622174)] 从上面的例子可以得出以下结论

append 方法不会影响原来的切片属性 append 方法会返回更新后的切片 更新后的切片容量没有超过更新前的容量时，这两个切片指向的地址是一样的。 append() 添加元素的个数超过 切片的 cap() 的时候，那么底层会 重新分配一个 “足够大” 的内存，一般来说是将原来的内存空间扩大二倍，然后将数据复制到新的内存中去， 原来的空间会保留 （供原先切片使用） 删除和插入元素

删除和插入元素可以用append 方法实现

func main(){ s1 := []int{1,2,3,4,5,6,7,8,9,10} fmt.Printf("origin data: len=%d cap=%d s1=%v\n",len(s1), cap(s1), s1) s1 = removeAt(s1, 5) fmt.Printf("after remove: len=%d cap=%d s1=%v\n",len(s1), cap(s1), s1) s1 = insertAt(s1, 5, 6) fmt.Printf("after insert: len=%d cap=%d s1=%v\n",len(s1), cap(s1), s1) }

func removeAt(src []int, index int)[]int{ src = append(src[0:index], src[index+1:]...) return src }

func insertAt(src []int, index int, data int)[]int{ rear := append([]int{}, src[index:]...) src = append(src[0:index], data) src = append(src, rear...) return src } [图片上传失败...(image-944535-1513159622174)]

复制

使用切片长时间引用超大的底层数组，会导致严重的内存浪费现象。 可以新建一个小的slice 对象，然后将所需要的数据复制过去，这样子就不会引用底层数组，直接拷贝了数据，这就是需求。函数 copy()可以 在切片之间复制元素。 copy函数返回复制元素个数，两个参数分别为目的方，源

copy() 可以复制的元素数量取决于 复制方 和 被复制方的最小长度。 同一个底层数组之间的 元素复制，会导致元素重叠问题。 func main(){ s1 := []int{1,2,3,4,5,6,7,8,9,10} s2 := make([]int, 3, 6) n := copy(s2, s1) fmt.Printf("n:%d s1:%v s2:%v\n", n, s1, s2)

//二者引用同一个底层数组
s3 := s1[1:5]
s4 := s1[2:7]
fmt.Println("s3: ",s3)
fmt.Println("s4: ",s4)
n = copy(s4, s3)
fmt.Printf("n:%d  s1:%v  s3:%v  s4:%v\n", n, s1, s3, s4)
复制代码

} [图片上传失败...(image-46aad6-1513159622174)] 至于这个结果，之所以s3,s4,s1会变，都是引用导致的。

Map

map是一个key-value的hash结构，是一个无序的数据的集合，通过键来进行索引得到对应的值。 这种方式可以加快查找速度。Map 通常称为 字典（dictionary） 或者哈希表(Hash table)。Map 现在是很多语言的标配

声明

var mapName map[keyType]valueType 注意：

不需要给字典指定长度，字典的长度会在初始化或者创建的过程中动态增长 Key 必须是能支持 比较运算符（==, !=）的数据类型，比如 整数，浮点数，指针，数组，结构体，接口等。 而不能是 函数，字典，切片这些类型。 Value 类型 可以是Go语言的任何基本数据类型 声明之后的map必须初始化或创建才能使用的，否则就是nil 例如以下是不通过的：

var mymap map[string]int mymap["key1"] = 1 使用{}在声明的时候初始化map map1 := map[string]string{} map1["key1"] = "value1" 使用make创建map map1 := make(map[string]string) map1["key1"] = "value1" map操作

查找

v, ok := mapName[key] 如果Key存在，将Key对应的Value赋值给v，OK== true. 否则 v 是0，OK==false.

删除

delete(mapName, "key1") 如果key1值不存在，那么调用将什么也不发生，也不会产生副作用。 但是，如果传入的map 是一个 nil，那么将导致程序出现异常，这一点在写程序的时候特别注意。

完

作者：ChainZhang 链接：https://www.jianshu.com/p/951c1dcdd2f1 來源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

转载于:https://juejin.im/post/5a6d9698f265da3e3304935b