本文为转载，原文：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，那么将导致程序出现异常，这一点在写程序的时候特别注意。
