本文为转载,原文: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,那么将导致程序出现异常,这一点在写程序的时候特别注意。
完
目录
上一节:Golang 学习笔记(03)—— 字符串操作
下一节:Golang 学习笔记(05)—— 面向对象编程