Go基础编程 - 05 - 数组与切片

上一篇：基本类型、常量和变量

下一篇：指针

1. 数组

数组是同一种类型固定长度的序列（有长度、类型构成）。一但定义，长度不可改变。

• 数组为值类型，赋值和传参会复制整个数组，而不是指针。
• 数组声明时，必须固定长度；长度是数组类型的一部分，不同长度的数组类型表示不同的类型（[2]int 与 [3]int 为不同的数组类型）；
• 数组未赋值，则初始化为类型缺省值（零值）。
• 内置函数len、cap都返回数组长度。
• 越界访问产生panic。
• 指针数组：[n]*T，数组指针：*[n]T。
• 值拷贝行为会造成性能问题，通常会建议使用 slice，或数组指针。

package mainimport ("fmt""reflect"
)func main() {// 初始化var arr1 [5]intvar arr2 = [5]int{0, 1, 2, 3, 4}var arr3 = [3]int{0, 2: 4}var arr4 = [...]int{1, 2, 3}fmt.Println(arr1, arr2, arr3, arr4)// 长度是数组类型的一部分，不同长度的数组类型为不同类型if reflect.TypeOf(arr1) == reflect.TypeOf(arr2) {fmt.Println("arr1 和 arr2 数据类型相同！")}if reflect.TypeOf(arr1) != reflect.TypeOf(arr3) {fmt.Println("arr1 和 arr3 数据类型不相同！")}// 数组为值类型：赋值和传参复制整个数组arr1copy := arr1arr1copy[0] = 10fmt.Println(arr1, arr1copy)// 值拷贝行为会造成性能问题，通常会建议使用 slice，或数组指针。fn := func(arr [5]int) {arr[1] = 20}fn(arr1)fmt.Println(arr1)// 指针数组：[n]*Tvar pa = [2]*int{new(int)}*pa[0] = 10pa[1] = new(int) // 引用类型必须先分配内存，须使用new分配内存*pa[1] = 20      // 若不分配内存（注释上一行代码），则产生panic: runtime error: invalid memory address or nil pointer dereferencefmt.Printf("pa:%v  \n", pa)// 数组指针：*[n]Tvar ap *[3]int // var ap = new([3]int)ap = new([3]int)*ap = [3]int{4, 5, 6}fmt.Printf("ap:%v  psr:%p  type:%T  \n", *ap, ap, ap)// 多维数组multArr := [...][2]int{{0, 0}, {1, 1}, {2, 2}}fmt.Println(multArr)
}

2. 切片

切片并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。

• 切片是引用类型；底层数据结构是一个数组，可以看作是对数组某个连续片段的引用。
• 切片是可变长的（包含长度、容量）。
• 长度：用len()函数求长度，表示可用元素数量，读写操作不能超过该限制。
• 容量：用cap()函数求最大容量，为切片底层数组的长度。
• 扩容及规律： 扩容通常以 2 倍容量重新分配底层数组；当原有切片容量大于 1024 时，以 1.25 倍扩容。
• 若 slice == nil，则 len、cap结果都等于 0。

2.1. slice 声明、初始化

package mainimport "fmt"func main() {// 声明var s []int     if s == nil {fmt.Println("s is nil")}s1 := []int{1, 2, 3, 4}// 使用 make()var s2 []int = make([]int, 0)s3 := make([]int, 5)s4 := make([]int, 5, 8)fmt.Println(s, s1, s2, s3, s4)fmt.Println("Cap：", cap(s), cap(s1), cap(s2), cap(s3), cap(s4))// 从数组切片arr := [5]int{1, 2, 3, 4, 5}var s5 []ints5 = arr[1:4] // 前包后不包fmt.Println(s5, len(s5), cap(s5))
}

2.2. slice 操作

• slice 的索引起点为 0。
• 切片截取：s[i:j:max]，满足 i <= j <= max；其中，i为起始索引（包含），省略值 0；j结束索引（不包含），省略值len(s)；max为截取最大索引，省略值len(s)。
• 截取新切片长度 = j - i
• 截取新切片容量 = max - i
• 截取新切片开始索引非 0，指针地址指向底层数组中新切片开始索引所在的地址；起始地址相同的slice指针地址相同，例：s[i], s[i:], s[i:j], s[i:j:max] 的指针引用地址都相同。

package mainimport "fmt"func main() {s := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}v := s[0]fmt.Println(v)s1 := s[2:5]s2 := s[2:8]s3 := s[:10:12]fmt.Println("val", v, s1, s2, s3)fmt.Println("len", len(s1), len(s2), len(s3))fmt.Println("cap", cap(s1), cap(s2), cap(s3))fmt.Printf("prs %p %p %p \n", s1, s2, s3)
}

2.3. append() 追加切片、扩容

append() 向 slice 尾部添加数据，返回新的 slice 对象。

扩容通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

package mainimport "fmt"func main() {arr := []int{0, 1, 2, 3, 4}fmt.Println("len =", len(arr), "cap =", cap(arr))       // len = 5  cap = 5arr1 := append(arr, 5)       // 追加数据，超出原切片容量，则进行扩容fmt.Println("len =", len(arr1), "cap =", cap(arr1))     // len = 6  cap = 10fmt.Printf("prs: %p %p \n", arr, arr1)  // 对比底层数组起始指针，扩容后重新分配底层数组，与原数组无关。arr1 = append(arr1, []int{6, 7, 8, 9, 10}...)fmt.Println("len =", len(arr1), "cap =", cap(arr1))     // len = 11 cap = 20
}

2.4. 字符串和切片

string 底层就是一个 byte/rune 的数组，因此，也可以进行切片操作。

package mainimport "fmt"func main() {str := "Hello, Chain"s1 := str[:5]println(s1) // Hello//string 本身是不可变的，因此要改变string中字符；需将字符转为slice，进行更改，再转为string//str[0] = 'X'     // 报错：cannot assign to str[0] (value of type byte)s := []byte(str) // 英文字符使用 byte，代表ASCII码的一个字符// 赋值需要使用单引号('')，单引号定义一个字符，双引号定义个字符串s = append(s, '!')str = string(s)fmt.Println(str)str2 := "你好，中国"s2 := []rune(str2) // 包含中文字符使用 rune，代表一个UTF-8字符s2[3] = '伟's2[4] = '大's2 = append(s2, []rune{'的', '中', '国'}...)fmt.Println(string(s2))
}

3. Copy

• 深拷贝：拷贝的是数据本身；值类型数据，默认是深拷贝，Array、Int、Sting、Struct、Bool、Float。
• 浅拷贝：拷贝的是数据地址；引用类型数据，默认浅拷贝，Map、Slice。

package mainimport "fmt"func main() {arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}arr2 := arrarr[1] = 10fmt.Println(arr, arr2)fmt.Printf("prs: %p %p \n", &arr, &arr2) // Array 属于深copyfmt.Println()s1 := arr[:6]s2 := arr[4:]s1[5] = 50 // Slice 属于浅copyfmt.Println(s1, s2)fmt.Printf("prs：%p %p \n", s1, s2)// copy函数只能用于切片，属于浅拷贝；允许元素区间重叠copy(s1, s2)s1[1] = 100fmt.Println(s1, s2, arr)
}

4. Array、Slice 内存布局