在Go语言中，数组和切片是两种常用的集合类型。它们之间的主要区别在于数组的长度是固定的，而切片的长度是可变的。本文将介绍数组和切片的基本概念、特点以及使用示例。
1. 数组
数组是一种固定长度的数据结构，其长度在声明时就已经确定，之后不能改变。数组的类型由元素类型决定。例如，一个包含整数的数组可以表示为[1]int或[2]int。
go
package main
import "fmt"
func main() {
var a1 int = 10
var a2 int = 20
fmt.Println(a1, a2) // 输出： 10 20
}2. 切片
切片是一种灵活的数据结构，其长度是可变的。切片的类型只包含元素的类型，而不包含长度。切片可以通过字面量或通过内置函数创建。切片的底层数据结构是一个动态数组。
go
package main
import "fmt"
func main() {
s := []int{1, 2, 3, 4, 5}
fmt.Println(s) // 输出： [1 2 3 4 5]
}3. 数组和切片的区别
- 数组的长度是固定的，而切片的长度是可变的。
- 数组的元素类型必须相同，而切片的元素类型可以不同。
- 数组是值类型，而切片是引用类型。这意味着对数组的修改不会影响到原始数组，而对切片的修改会影响到原始数组。
4. 使用示例
下面是一些使用数组和切片的示例代码：
4.1 创建数组
go
package main
import "fmt"
func main() {
var arr1 [2]int = [2]int{1, 2}
var arr2 [3]int = [3]int{3, 4, 5}
fmt.Println(arr1, arr2) // 输出： [1 2] [3 4 5]
}4.2 创建切片
go
package main
import "fmt"
func main() {
var s1 []int = []int{1, 2, 3, 4, 5}
var s2 []int = make([]int, 3)
fmt.Println(s1, s2) // 输出： [1 2 3 4 5] [0 0 0]
}4.3 访问数组和切片的元素
go
package main
import "fmt"
func main() {
var arr1 [2]int = [2]int{1, 2}
var arr2 [3]int = [3]int{3, 4, 5}
var s1 []int = []int{1, 2, 3, 4, 5}
var s2 []int = make([]int, 3)
fmt.Println(arr1[0], arr1[1]) // 输出： 1 2
fmt.Println(arr2[0], arr2[1], arr2[2]) // 输出： 3 4 5
fmt.Println(s1[0], s1[1], s1[2]) // 输出： 1 2 3
fmt.Println(s2[0], s2[1], s2[2]) // 输出： 0 0 0
}4.4 修改数组和切片的元素
go
package main
import "fmt"
func main() {
var arr1 [2]int = [2]int{1, 2}
var arr2 [3]int = [3]int{3, 4, 5}
var s1 []int = []int{1, 2, 3, 4, 5}
var s2 []int = make([]int, 3)
arr1[0] = 10
arr2[1] = 20
s1[2] = 30
s2[0] = 40
fmt.Println(arr1, arr2) // 输出： [10 2] [3 20 5]
fmt.Println(s1, s2) // 输出： [1 2 30] [40 0 0]
}4.5 遍历数组和切片
go
package main
import "fmt"
func main() {
var arr1 [2]int = [2]int{1, 2}
var arr2 [3]int = [3]int{3, 4, 5}
var s1 []int = []int{1, 2, 3, 4, 5}
var s2 []int = make([]int, 3)
for i := 0; i < len(arr1); i++ {
fmt.Println(arr1[i]) // 输出： 1 2
}
for i := 0; i < len(arr2); i++ {
fmt.Println(arr2[i]) // 输出： 3 4 5
}
for i := 0; i < len(s1); i++ {
fmt.Println(s1[i]) // 输出： 1 2 3 4 5
}
for i := 0; i < len(s2); i++ {
fmt.Println(s2[i]) // 输出： 40 0 0
}
}5. 知识扩展
1. 问题：怎样估算切片容量的增长？
一旦一个切片无法容纳更多的元素，Go 语言就会想办法扩容。但它并不会改变原来的切片，而是会生成一个容量更大的切片，然后将把原有的元素和新元素一并拷贝到新切片中。在一般的情况下，你可以简单地认为新切片的容量（以下简称新容量）将会是原切片容量（以下简称原容量）的 2 倍。
但是，当原切片的长度（以下简称原长度）大于或等于1024时，Go 语言将会以原容量的1.25倍作为新容量的基准（以下新容量基准）。新容量基准会被调整（不断地与1.25相乘），直到结果不小于原长度与要追加的元素数量之和（以下简称新长度）。最终，新容量往往会比新长度大一些，当然，相等也是可能的。
另外，如果我们一次追加的元素过多，以至于使新长度比原容量的 2 倍还要大，那么新容量就会以新长度为基准。注意，与前面那种情况一样，最终的新容量在很多时候都要比新容量基准更大一些。更多细节可参见runtime包中 slice.go 文件里的growslice及相关函数的具体实现。
2. 问题：切片的底层数组什么时候会被替换？
确切地说，一个切片的底层数组永远不会被替换。为什么？虽然在扩容的时候 Go 语言一定会生成新的底层数组，但是它也同时生成了新的切片。它是把新的切片作为了新底层数组的窗口，而没有对原切片及其底层数组做任何改动。
请记住，在无需扩容时，append函数返回的是指向原底层数组的新切片，而在需要扩容时，append函数返回的是指向新底层数组的新切片。所以，严格来讲，"扩容"这个词用在这里虽然形象但并不合适。不过鉴于这种称呼已经用得很广泛了，我们也没必要另找新词了。
顺便说一下，只要新长度不会超过切片的原容量，那么使用append函数对其追加元素的时候就不会引起扩容。这只会使紧邻切片窗口右边的（底层数组中的）元素被新的元素替换掉。