1 数组

1.1 如何定义数组

数组是具有相同类型且长度固定的一组连续数据。在go语言中我们可以使用如下几种方式来定义数组。

//方式一
var arr1 = [5]int{}
//方式二
var arr2 = [5]int{1,2,3,4,5}
//方式三
var arr3 = [5]int{3:10}

输出以上三个变量的值如下所示：

arr1 [0 0 0 0 0]
arr2 [1 2 3 4 5]
arr3 [0 0 0 10 0]

• 方法一在声明时没有为其指定初值，所以数组内的值被初始化为类型的零值。
• 方法二使用显示的方式为数组定义初值。
• 方法三通过下标的方式为下标为3的位置赋上了初值10

而且在数组的定义是包含其长度的，也就是说[3]int与[4]int是两种不同的数据类型。

1.2 如何操作数据

在上面的arr1我们没有为其指定初值，那么之后我们可以通过循环的方式为其赋予初值

for i := 0; i < len(arr1); i++ {
        arr1[i] = i * 10
    }

此时我们再输出一下数组arr1，可以看到其值已经变化

arr1 update:  [0 10 20 30 40]

我们还可以通过循环的方式遍历数组，与上面不同的是，for循环提供这样的方式来为便利数组

for index, value := range arr1 {
        fmt.Printf("index: %d, value: %d\n", index, value)
    }

通过range来遍历数组会有两个返回值，其中第一个为数组的索引，第二个位置为对应的值，输出结果如下：

index: 0, value: 0
index: 1, value: 10
index: 2, value: 20
index: 3, value: 30
index: 4, value: 40

当然不想要索引值也是可以的，可以用_代替。

1.3 多维数组

与其他语言一样，go语言也可以定义多维数组，可以选择的定义方式如下：

var arr4 = [5][5]int{
        {1, 2, 3, 4, 5},
        {6, 7, 8, 9, 10},
    }

输出当前数组，可以看到数组内的值如下所示

[[1 2 3 4 5] [6 7 8 9 10] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

1.4 数组作为函数参数

go语言在传递数组时会对其进行拷贝，所以如果传递的是大数组的话会非常占内存，所以一般情况下很少直接传递一个数组，避免这种情况我们可以使用以下两种方式：

• 传递数组的指针
• 传递切片（具体内容见下一小节）

1.5 指针数组与数组指针

对于指针数组和数组指针在c或c++中也经常被讨论，尤其对于初学者来说会分辨不清楚。其实在每个词中间添加一个“的“就很好理解了，指针的数组，数组的指针。

1.指针数组

对于指针数组来说，就是：一个数组里面装的都是指针，在go语言中数组默认是值传递的，所以如果我们在函数中修改传递过来的数组对原来的数组是没有影响的。

func main() {
    var a [5]int
    fmt.Println(a)
    test(a)
    fmt.Println(a)
}

func test(a [5]int) {
    a[1] = 2
    fmt.Println(a)
}

输出

[0 0 0 0 0]
[0 2 0 0 0]
[0 0 0 0 0]

但是如果我们一个函数传递的是指针数组，情况会有什么不一样呢？

func main() {
    var a [5]*int
    fmt.Println(a)
    for i := 0; i < 5; i++ {
        temp := i
        a[i] = &temp
    }
    for i := 0; i < 5; i++ {
        fmt.Print(" ", *a[i])
    }
    fmt.Println()
    test1(a)
    for i := 0; i < 5; i++ {
        fmt.Print(" ", *a[i])
    }
}

func test1(a [5]*int) {
    *a[1] = 2
    for i := 0; i < 5; i++ {
        fmt.Print(" ", *a[i])
    }
    fmt.Println()
}

我们先来看一下程序的运行结果

[<nil> <nil> <nil> <nil> <nil>]
 0 1 2 3 4
 0 2 2 3 4
 0 2 2 3 4

可以看到初始化值全是nil，也就验证了指针数组内部全都是一个一个指针，之后我们将其初始化，内部的每个指针指向一块内存空间。

注：在初始化的时候如果直接另a[i] = &i那么指针数组内部存储的全是同一个地址，所以输出结果也一定是相同的

然后我们将这个指针数组传递给test1函数，对于数组的参数传递仍然是复制的形式也就是值传递，但是因为数组中每个元素是一个指针，所以test1函数复制的新数组中的值仍然是这些指针指向的具体地址值，这时改变a[1]这块存储空间地址指向的值，那么原实参指向的值也会变为2，具体流程如下图所示。

2.数组指针

了解了指针数组之后，再来看一下数组指针，数组指针的全称应该叫做，指向数组的指针，在go语言中我们可以如下操作。

func main() {
    var a [5]int
    var aPtr *[5]int
    aPtr = &a
    //这样简短定义也可以aPtr := &a
    fmt.Println(aPtr)
    test(aPtr)
    fmt.Println(aPtr)
}

func test(aPtr *[5]int) {
    aPtr[1] = 5
    fmt.Println(aPtr)
}

我们先定义了一个数组a，然后定一个指向数组a的指针aPtr，然后将这个指针传入一个函数，在函数中我们改变了具体的值，程序的输出结果

&[0 0 0 0 0]
&[0 5 0 0 0]
&[0 5 0 0 0]

通过上面的图我们可以看见虽然main和test函数中的aPtr是不同的指针，但是他们都指向同一块数组的内存空间，所以无论在main函数还是在test函数中对数组的操作都会直接改变数组。

2 切片

因为数组是固定长度，所以在一些场合下就显得不够灵活，所以go语言提供了一种更为便捷的数据类型叫做切片。切片操作与数据类似，但是它的长度是不固定的，可以追加元素，如果以达到当前切片容量的上限会再自动扩容。

2.1 如何定义切片

可以通过以下几种方式定义切片

package main

import "fmt"

func main() {
    //方法一：声明了一个空切片
    var s1 = []int{}
    //方法二：声明了一个长度为3的切片
    var s2 = []int{1, 2, 3}
    //方法三：声明了一个长度为5的空切片
    var s3 = make([]int, 5)
    //方法四：声明了一个长度为5容量为10的切片
    var s4 = make([]int, 5, 10)

    //可以看到切片的定义与数组类似，但是定义切片不需要为其指定长度。

    //我们可以通过len()和cap()这两个函数来获取切片的长度和容量，下面就来依次看下上面各切片的长度以及容量。
    fmt.Println("s1", s1, len(s1), cap(s1))
    fmt.Println("s2", s2, len(s2), cap(s2))
    fmt.Println("s3", s3, len(s3), cap(s3))
    fmt.Println("s4", s4, len(s4), cap(s4))

    //如果我们通过这种方式定义一个切片，那么他会被赋予切片的空值nil。
    var s5 []int
    fmt.Println("s5", s5, len(s5), cap(s5))

}

执行结果

s1 [] 0 0
s2 [1 2 3] 3 3
s3 [0 0 0 0 0] 5 5
s4 [0 0 0 0 0] 5 10
s5 [] 0 0

切片操作
我们可以通过如下的方式在数组和切片上继续获取切片

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    s := []int{6, 7, 8, 9, 10}

    s1 := arr[2:4] //起始位0，从第2位到第4位前
    s2 := arr[:3]  //从起始位0，到第3位前
    s3 := arr[2:]  //从第2位到终了位
    s4 := s[1:3]   //从第1位到第3位前

    fmt.Println("s1:", s1)
    fmt.Println("s2:", s2)
    fmt.Println("s3:", s3)
    fmt.Println("s4:", s4)
}

执行结果

s1: [3 4]
s2: [1 2 3]
s3: [3 4 5]
s4: [7 8]

可以看到切片操作是“包左不包右”，例如arr[2:4]是选择arr数组内下标为2，3的两个元素。如果:左边没有起始位置则默认从头开始，同理如果右边没有终止位置则默认到末尾。

2.2 切片的扩充与拼接

我们之前介绍了切片的定义以及一些切片的操作，下面就来看一下如何对切片进行扩充。

package main

import "fmt"

func main() {
    a := []int{1, 2, 3}
    b := a[1:3]

    b = append(b, 4)
    b = append(b, 5)
    b = append(b, 6)
    b = append(b, 7)

    fmt.Println(a)
    fmt.Println(b)
}

执行结果

[1 2 3]
[2 3 4 5 6 7]

如果想要将两个切片进行拼接可以使用如下这种方式：

package main

import "fmt"

func main() {
    a := []int{1, 2, 3}
    b := a[1:3]

    fmt.Println(b)

    a = append(a, b...)//两个切片，关键...

    fmt.Println(a)
}

执行结果

[2 3]
[1 2 3 2 3]

如果我们想要将一个切片的值复制给另一个切片，go语言也提供了非常简便的方式。

package main

import "fmt"

func main() {
    a := []int{1, 2, 3}
    b := make([]int, 6)

    fmt.Println(a)
    fmt.Println(b)

    copy(b, a) //copy(拷贝先，拷贝元)

    fmt.Println(a)
    fmt.Println(b)
}

执行结果

[1 2 3]
[0 0 0 0 0 0]
[1 2 3]
[1 2 3 0 0 0]

你不妨动手试一试下面几个操作结果会怎么样：

声明b切片时，其长度比a切片长，复制结果是怎么样的？
声明b切片时，其长度比a切片短，复制结果是怎么样的？
声明b切片时，其长度被定义为0，那么调用copy函数会报错吗？

package main

import "fmt"

func main() {
    a := []int{1, 2, 3}
    b := make([]int, 6)
    c := make([]int, 2)
    d := make([]int, 0)

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)

    copy(b, a) //copy(拷贝先，拷贝元) 长
    copy(c, a) //copy(拷贝先，拷贝元) 短
    copy(d, a) //copy(拷贝先，拷贝元) 0

    fmt.Println("a:", a)
    fmt.Println("b:", b)
    fmt.Println("c:", c)
    fmt.Println("d:", d)
}

执行结果

[1 2 3]
[0 0 0 0 0 0]
[0 0]
[]
a: [1 2 3]
b: [1 2 3 0 0 0]
c: [1 2]
d: []

结合append与copy函数可以实现很多非常实用的功能，你也可以动手尝试一下😀
删除处于索引i的元素
在索引i的位置插入元素
在索引i的位置插入长度为 j 的新切片

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
    i := 1
    //删除处于索引i的元素
    fmt.Println("删除前：", a)
    b := a[:i]
    c := a[i+1:]

    fmt.Println(append(b, c...))
    fmt.Println("删除后：", a)

    //在索引i的位置插入元素
    aa := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
    fmt.Println("插入元素前：", aa)
    d := aa[:i] //1
    e := aa[i:] //2,3,4,5,6,7,8,9,0

    ch := make([]int, len(d)+1) //
    copy(ch, d)
    ch[i] = 10
    f := append(ch, e...)
    fmt.Println("插入元素后：", f)

    //在索引i的位置插入长度为j的新切片
    aaa := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
    ins := []int{11, 22}
    fmt.Println("插入元素前：", aaa)
    dd := aaa[:i] //1
    ee := aaa[i:] //2,3,4,5,6,7,8,9,0

    chh := make([]int, len(dd))
    copy(chh, dd)
    chhh := append(chh, ins...)

    ff := append(chhh, ee...)
    fmt.Println("插入元素后：", ff)
}

等等

删除前： [1 2 3 4 5 6 7 8 9 0]
[1 3 4 5 6 7 8 9 0]
删除后： [1 3 4 5 6 7 8 9 0 0]
插入元素前： [1 2 3 4 5 6 7 8 9 0]
插入元素后： [1 10 2 3 4 5 6 7 8 9 0]
插入元素前： [1 2 3 4 5 6 7 8 9 0]
插入元素后： [1 11 22 2 3 4 5 6 7 8 9 0]

2.3 切片与数组的关系

对于任何一个切片来说，其都有一个底层数组与之对应，我们可以将切片看作是一个窗口，透过这个窗口可以看到底层数组的一部分元素，对应关系如下图所示。

微信图片_20201218234711.png

下面有几个问题欢迎你自己动手尝试一下：

编写程序看看切片的容量与数组的大小有什么关系呢？

如果我们在切片上再做切片那么他们会指向相同的底层数组吗？修改其中一个切片会影响其他切片的值么？其中一个切片扩容到容量大小之后会更换底层数组，那么之前的其他切片也会指向新的底层数组吗？

既然切片是引用底层数组的，需要注意的就是小切片引用大数组的问题，如果底层的大数组一直有切片进行引用，那么垃圾回收机制就不会将其收回，造成内存的浪费，最有效的做法是copy需要的数据后再进行操作