本文为转载，原文：Golang 学习笔记（04）—— array, slice, map

Golang

介绍

• 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)]
从上面的例子可以得出以下结论

1. append 方法不会影响原来的切片属性
2. append 方法会返回更新后的切片
3. 更新后的切片容量没有超过更新前的容量时，这两个切片指向的地址是一样的。
4. 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）—— 面向对象编程