数组
定义： 固定长度且拥有零个或者多个相同数据类型元素的序列,数组组成：长度和元素
概念：
- 数组是值类型（非指针传参情况时，会对原始数据进行数据复制，修改参数时不更改原始数组）
- 数组长度定义后就不可更改，可以使用常量表达式定义长度（编译时会及计算结果）
- 数组索引从0开始，内置len函数返回数组元素个数，数组的长度是数组的一部分
- go语言支持多维数组，支持range遍历
声明方式
- 普通声明
package main
import "fmt"
func main() {
// 声明长度为3的int类型数组，默认数组元素都是零值，int的零值是0
var arr [3]int
for i, v := range arr {
fmt.Printf("index:%d,value:%d ,type：%T ", i, v)
fmt.Println()
}
// 声明长度为3的string类型数组，默认数组元素都是零值，string的零值是空
var arrStr [3]string
for i, v := range arrStr {
fmt.Printf("index:%d,value:%s ,type：%T ", i, v)
fmt.Println()
}
}out
index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string
index:1,value:2 ,type：string
index:2,value:3 ,type：string- 字面量声明
package main
import "fmt"
func main() {
// 声明长度为3的int类型数组，并且初始化数组元素,打印类型
var arr [3]int = [3]int{1, 2, 3}
for i, v := range arr {
fmt.Printf("index:%d,value:%d ,type：%T", i, v, v)
fmt.Println()
}
// 声明长度为3的string类型数组,并且初始化数组元素,打印类型
var arrStr [3]string = [3]string{"1", "2", "3"}
for i, v := range arrStr {
fmt.Printf("index:%d,value:%s ,type：%T ", i, v, v)
fmt.Println()
}
}out
index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string
index:1,value:2 ,type：string
index:2,value:3 ,type：string- 字面量扩展声明
package main
import "fmt"
func main() {
// 声明int类型数组,数组长度根据元素个数推断
arr := [...]int{1, 2, 3}
for i, v := range arr {
fmt.Printf("index:%d,value:%d ,type：%T", i, v, v)
fmt.Println()
}
// 声明string类型数组,数组长度根据元素个数推断
arrStr := [...]string{"1", "2", "3"}
for i, v := range arrStr {
fmt.Printf("index:%d,value:%s ,type：%T ", i, v, v)
fmt.Println()
}
}out
index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string
index:1,value:2 ,type：string
index:2,value:3 ,type：string- 索引声明
package main
import "fmt"
func main() {
// 声明string类型数组,指定索引位置生成指定元素，其他的全部省略
// 这里声明的索引位置是3，表示下面定义了一个长度为4的数组，索引3处是"3",其他全是空
arrStr := [...]string{3: "3"}
for i, v := range arrStr {
fmt.Printf("index:%d,value:%s,type：%T ", i, v, v)
fmt.Println()
}
}out
index:0,value:,type：string
index:1,value:,type：string
index:2,value:,type：string
index:3,value:3,type：string数组比较
数组比较定义：如果一个数组元素类型是可比较的，这个数组就是可比较的
package main
import "fmt"
func main() {
// 声明方式不同，但是最终的数组是一样的
arr1 := [3]int{1, 2, 3}
arr2 := [...]int{1, 2, 3}
fmt.Printf("arr1 == arr2 => %v", arr1 == arr2)
// arr1 == arr2=>true
arr3 := [3]int{1, 2, 3}
arr4 := [...]int{1, 2, 3, 4}
// 数组的长度是数组的一部分，如果长度不同，直接报错，无法比较
// cannot compare arr3 == arr4 (mismatched types [3]int and [4]int)
fmt.Printf("arr3 == arr4 => %v", arr3 == arr4)// 报错了
}访问与遍历
- 索引访问
func main() {
// 索引访问
arr := [...]int{1, 2, 3}
fmt.Printf("arr index 0 = %v", arr[0])
}out
arr index 0 = 1- 遍历
func main() {
// 索引遍历
arr := [...]int{1, 2, 3}
for i := 0; i < len(arr); i++ {
fmt.Printf("index: %d, value: %v", i, arr[i])
fmt.Println()
}
}
func main() {
// range 遍历
arr := [...]int{1, 2, 3}
for index, value := range arr {
fmt.Printf("index: %d, value: %v", index, value)
fmt.Println()
}
}out
index: 0, value: 1
index: 1, value: 2
index: 2, value: 3
//=========================
index: 0, value: 1
index: 1, value: 2
index: 2, value: 3数组传参
- 副本传参
func main() {
// 索引遍历
arr := [...]int{1, 2, 3}
test(arr)
// 调用test之后，打印arr元素
for index, value := range arr {
fmt.Printf("main index: %d, value: %v", index, value)
fmt.Println()
}
}
func test(arr [3]int) {
// 这里改变index 1处的value
arr[1] = 100
for index, value := range arr {
fmt.Printf("test index: %d, value: %v", index, value)
fmt.Println()
}
}out
test index: 0, value: 1
test index: 1, value: 100
test index: 2, value: 3
main index: 0, value: 1
main index: 1, value: 2
main index: 2, value: 3- 指针传参
func main() {
// 索引遍历
arr := [...]int{1, 2, 3}
test(&arr)
for index, value := range arr {
fmt.Printf("main index: %d, value: %v", index, value)
fmt.Println()
}
}
func test(arr *[3]int) {
arr[1] = 100
for index, value := range arr {
fmt.Printf("test index: %d, value: %v", index, value)
fmt.Println()
}
}out
test index: 0, value: 1
test index: 1, value: 100
test index: 2, value: 3
main index: 0, value: 1
main index: 1, value: 100
main index: 2, value: 3切片
- 定义：可变长度且拥有零个或者多个相同数据类型元素的序列
- 属性：指针，长度，容量
- 指针：指向数组第一个可以从slice中访问的元素
- 长度：slice的元素个数
- 容量：slice的起始元素到数组的最后一个元素之间的个数
- 一个数组可以对应多个slice，并且如果有切片引用了数组，数组不会被回收
查看切片属性
- 长度与容量
func main() {
// 引用数组
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s := arr[2:5] // index 2~4
fmt.Printf(" slice is %v ", s)
fmt.Println()
fmt.Printf(" slice len is %v , cap is %v ", len(s), cap(s))
fmt.Println()
}out
slice is [2 3 4]
slice len is 3 , cap is 8 // 容量是从index 2 开始到 index 9 结束 => 8创建切片
- 直接引用数组:
- [i:j] 左闭右开区间
func main() {
// 引用数组
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
// [i:j] 0<= i <= j <= cap(arr)
// 切片引用的序列为 索引第i个(包含i) 到 第j-1个 左闭右开区间
s := arr[0:10] // index 0~9
s2 := arr[:] // index 0~9
s3 := arr[2:] // index 2~9
s4 := arr[:7] // index 0~6
// s5 := arr[:12] // index 12 (constant of type int) is out of boundscompiler
fmt.Printf(" slice1 is %v ", s)
fmt.Println()
fmt.Printf(" slice2 is %v ", s2)
fmt.Println()
fmt.Printf(" slice3 is %v ", s3)
fmt.Println()
fmt.Printf(" slice4 is %v ", s4)
fmt.Println()
}out
slice1 is [0 1 2 3 4 5 6 7 8 9]
slice2 is [0 1 2 3 4 5 6 7 8 9]
slice3 is [2 3 4 5 6 7 8 9]
slice4 is [0 1 2 3 4 5 6]- 字面量创建切片
func main() {
// 创建数组，创建之初已有固定长度
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Printf(" arr is %v , type：%T", arr, arr)
fmt.Println()
// 字面量创建出来的不定长序列，没有推断长度
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
fmt.Printf(" slice is %v , type：%T , len is %v , cap is %v ", s, s, len(s), cap(s))
fmt.Println()
// 基于创建的切片，追加一个元素10
s = append(s, 10)
fmt.Printf(" slice is %v , type：%T , len is %v , cap is %v ", s, s, len(s), cap(s))
fmt.Println()
}out
arr is [0 1 2 3 4 5 6 7 8 9] , type：[10]int
slice is [0 1 2 3 4 5 6 7 8 9] , type：[]int , len is 10 , cap is 10
slice is [0 1 2 3 4 5 6 7 8 9 10] , type：[]int , len is 11 , cap is 20- make
func main() {
s := make([]int, 5, 5)
fmt.Printf(" slice is %v ", s)
fmt.Println()
s = append(s, 1)
fmt.Printf(" slice is %v ", s)
fmt.Println()
}out
slice is [0 0 0 0 0]
slice is [0 0 0 0 0 1]
指定容量的同时指定了长度，go中会给元素加上对应的默认值，再次append操作，会重新扩容，追加元素常用make的姿势
func main() {
s := make([]int, 0, 5)
fmt.Printf(" slice is %v ", s)
fmt.Println()
s = append(s, 1)
fmt.Printf(" slice is %v ", s)
fmt.Println()
}out
slice is []
slice is [1]
指定切片的容量，但是不指定长度，切片不会给元素加默认值，实际中切片可以按照预期正常追加，并且减少内存分配的次数append与扩容
定义：内置函数，用来将元素追加到slice的尾部
每一次的append调用都会检查slice是否有足够的容量来添加新元素
- 容量足够时append：创建一个新的slice，将新元素复制到末尾，并返回新的slice
- 容量不够时append：创建一个新的拥有足够容量的新的底层数组，一般是2倍增长，然后将原slice复制到新数组中，再将新元素追加到数组末尾，再次创建新的slince引用，返回新的slice，此时append前后的底层数组已经发生了改变
func main() {
arr := []int{1, 2}
arr = append(arr, 3)
fmt.Printf(" arr is %v", arr)
}out
arr is [1 2 3]append解析
func main() {
arr := []int{1, 2}
arr = appendTheory(arr, 3)
fmt.Printf("arr is %v", arr)
}
func appendTheory(arr []int, value int) []int {
var newArr []int
newArrLen := len(arr) + 1
if newArrLen <= cap(arr) {
newArr = arr[:newArrLen]
} else {
newArrCap := newArrLen
if newArrCap < 2*len(arr) {
newArrCap = 2 * len(arr)
}
newArr = make([]int, newArrLen, newArrCap)
copy(newArr, arr)
}
newArr[len(arr)] = value
return newArr
}out
arr is [1 2 3]扩容解析
func main() {
var arr []int
for i := 0; i < 10; i++ {
arr = append(arr, i)
fmt.Printf("index is %d, cap is %d , len is %d \t %v \n", i, cap(arr), len(arr), arr)
}
}out
index is 0, cap is 1 , len is 1 [0]
index is 1, cap is 2 , len is 2 [0 1]
index is 2, cap is 4 , len is 3 [0 1 2]
index is 3, cap is 4 , len is 4 [0 1 2 3]
index is 4, cap is 8 , len is 5 [0 1 2 3 4]
index is 5, cap is 8 , len is 6 [0 1 2 3 4 5]
index is 6, cap is 8 , len is 7 [0 1 2 3 4 5 6]
index is 7, cap is 8 , len is 8 [0 1 2 3 4 5 6 7]
index is 8, cap is 16 , len is 9 [0 1 2 3 4 5 6 7 8]
index is 9, cap is 16 , len is 10 [0 1 2 3 4 5 6 7 8 9]切片传参
切片包含指向首元素的指针。虽然函数的传参是值传递，但是指针始终指向同一个数组，所以更改切片会直接影响函数外部的原始切片
func main() {
arr := []int{1, 2}
result := update(arr, 1, 3)
fmt.Printf("arr is %v", result)
}
func update(arr []int, index, value int) []int {
arr[index] = value
return arr
}out
arr is [1 3]
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
