Go语言の数组与切片
- 本文章主要讲Go语言的数组与切片
为什么需要数组
问题
一个养鸡场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平均体重是多少? 请你编一个程序。=》数组
使用传统方法来解决
package main import ( "fmt" ) func main(){ hen1 := 3.0 hen2 := 5.0 hen3 := 1.0 hen4 := 3.4 hen5 := 2.0 hen6 := 50.0 totalWeight := hen1 + hen2 + hen3 + hen4 + hen5 + hen6 avgWeight := fmt.Sprintf("%.2f", totalWeight / 6) fmt.Printf("totalWeight = %v,avgWeight = %v \n", totalWeight, avgWeight) }totalWeight = 64.4,avgWeight = 10.73说明：
- 使用传统方法不利于数据的管理和维护
- 传统的方法不够灵活，因此我们需要引出新的数据类型：数组
数组介绍
数组可以存放多个同一类型数据。数组也是一种数据类型，在 Go 中，数组是值类型。
数组的快速入门
我们使用数组的方法来解决养鸡场的问题
package main
import (
"fmt"
)
func main(){
var hens [7]float64
hens[0] = 3.0
hens[1] = 5.0
hens[2] = 1.0
hens[3] = 3.4
hens[4] = 2.0
hens[5] = 50.0
hens[6] = 150.0
totalWeight := 0.0
for i := 0; i < len(hens); i++ {
totalWeight += hens[i]
}
avgWeight := fmt.Sprintf("%.2f", totalWeight / float64(len(hens)))
fmt.Printf("totalWeight = %v,avgWeight = %v \n", totalWeight, avgWeight)
}totalWeight = 214.4,avgWeight = 30.63 说明：
1. 使用数组来解决问题，程序的可维护性增加
2. 方法代码更加清晰，也容易扩展
数组定义和内存布局
定义
var 数组名 [数组大小]数据类型 var a [5]int //赋初值 a[0] = 1 a[1] = 30 //......数组在内存布局（重要）
- 对上图的总结：
- 数组的地址可以通过数组名来获取
&intArr - 数组的第一个元素的地址，就是数组的首地址
- 数组的各个元素的地址间隔是依据数组的类型决定，比如
int64->8 int32->4...
package main import ( "fmt" ) func main(){ var intArr [3]int // int占8个字节 //当我们定义完数组后，其实数组的各个元素有默认值 0 fmt.Println(intArr) intArr[0] = 10 intArr[1] = 20 intArr[2] = 30 fmt.Println(intArr) fmt.Printf("intArr的地址=%p intArr[0]的地址=%p intArr[1]的地址=%p intArr[2]的地址=%p \n",&intArr, &intArr[0],&intArr[1],&intArr[2]) }~/go/src/go_code/chapter07/demo02/main go run ./main.go [0 0 0] [10 20 30] intArr的地址=0xc0000b8000 intArr[0]的地址=0xc0000b8000 intArr[1]的地址=0xc0000b8008 intArr[2]的地址=0xc0000b8010数组的使用
- 访问数组元素
数组名[下标] 比如：你要使用a数组的第三个元素 a[2]
- 快速入门案例
从终端循环输入5个成绩，保存到float64数组，并输出。
var score [5]float64 for i := 0;i < len(score); i++ { fmt.Printf("请输入第%d个元素的值\n", i+1) fmt.Scanln(&score[i]) } //变量数组打印 for i := 0; i < len(score); i++ { fmt.Printf("score[%d]=%v", i, score[i]) }~/go/src/go_code/chapter07/demo02/main go run ./main.go 请输入第1个元素的值 5 请输入第2个元素的值 4 请输入第3个元素的值 3 请输入第4个元素的值 2 请输入第5个元素的值 1 score[0]=5 score[1]=4 score[2]=3 score[3]=2 score[4]=1- 四种初始化数组的方式
func main(){ //四种初始化数组的方式 var numArr01 [3]int = [3]int{1, 2, 3} fmt.Println("numArr01=", numArr01) var numArr02 = [3]int{5,6,7} fmt.Println("numArr02=", numArr02) //这里的[...]是规定的写法 var numArr03 = [...]int{8, 9, 10} fmt.Println("numArr03=", numArr03) var numArr04 = [...]int{1:800, 0:900, 2:999} fmt.Println("numArr04=", numArr04) //类型推导 strArr05 := [...]string{1: "tom", 2:"jack", 3:"rose"} fmt.Println("strArr05=",strArr05) }~/go/src/go_code/chapter07/demo02/main go run ./main.go numArr01= [1 2 3] numArr02= [5 6 7] numArr03= [8 9 10] numArr04= [900 800 999] strArr05= [ tom jack rose]数组的遍历
方式1-常规遍历
看上面的，不再赘述
方式2-for-range结构遍历
这是Go语言的独有的结构，可以用来遍历访问数组的元素。
- for-range的基本语法
for index, value := range array01 { ... }说明
- 第一个返回值index是数组的下标
- 第二个value是在该下标位置的值
- 他们都是仅在for循环内部可见的局部变量
- 遍历数组元素的时候，如果不想使用下标index，可以直接把下标index标为下划线_
- index和value的名称不是固定的，即程序员可以自行指定，一般命名为index和value
- for-range的案例
func main(){ //演示for-range遍历数组 heroes := [...]string{"宋江", "吴用", "卢俊义"} for i, v := range heroes { fmt.Printf("i=%v v=%v",i, v) fmt.Printf("heroes[%d]=%v\n", i, heroes[i]) } for _, v := range heroes { fmt.Printf("元素的值=%v\n", v) } }~/go/src/go_code/chapter07/demo02/main go run ./main.go i=0 v=宋江heroes[0]=宋江 i=1 v=吴用heroes[1]=吴用 i=2 v=卢俊义heroes[2]=卢俊义 元素的值=宋江 元素的值=吴用 元素的值=卢俊义数组使用的注意事项和细节
- 数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化
func main(){ //数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化。 var arr01 [3]int arr01[0] = 1 arr01[1] = 30 //会报错 arr01[2] = 1.1 //数组类型和初始化的值的类型不匹配哦 //其长度是固定的，不能动态变化，否则报越界 arr01[3] = 890 //数组不能动态增长 fmt.Println(arr01) }var arr []int这时arr就是一个slice切片，切片后面专门讲解。数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
数组创建后，如果没有赋值，有默认值（零值）
数组类型数组： 默认值为 0 字符串数组： 默认值为 "" bool数组： 默认值为false
var arr01 [3]float32 var arr02 [3]string var arr03 [3]bool fmt.Printf("arr01=%v arr02=%v arr03=%v\n", arr01, arr02, arr03)- 使用数组的步骤
- 生命数组并开辟空间
- 给数组各个元素赋值（默认零值）
- 使用数组
- 数组的下标是从0开始的
var arr04 [3]string // 0-2 var index int = 3 arr04[index] = "tom" //arr04[3]越界奥- 数组下标必须在指定范围内使用，否则报panic：数组越界，比如
var arr [5]int则有效下标为0-4 - Go的数组属值类型，在默认情况下是值传递，因此会进行值拷贝。数组见不会相互影响
如想在其它函数中，去修改原来的数组，可以使用引用传递（指针方式）
长度是数组类型的一部分，在传递函数参数时 需要考虑数组的长度，看下面的案例：
数组的应用案例
- 创建一个byte类型的26个元素的数组，分别放置’A’-‘Z’.使用for循环访问所有元素并打印出来。提示：字符数据运算’A’+1->’B’
func main(){
var arr01 [26]byte
for i := 0; i < len(arr01); i++ {
arr01[i] = 'A' + byte(i)//要将i转成byte类型
}
for i := 0; i < len(arr01); i++ {
fmt.Printf("%c", arr01[i])
}
fmt.Println();
} ~/go/src/go_code/chapter07/demo02/main go run ./main.go
ABCDEFGHIJKLMNOPQRSTUVWXYZ- 请求出一个数组的最大值，并得到对应的下标。
func main(){
var intArr [6]int = [...]int {1,2,932,42,-1,32}
maxVal := intArr[0]
maxValIndex := 0
for i := 0; i < len(intArr); i++ {
if intArr[i]>maxVal {
maxVal = intArr[i]
maxValIndex = i
}
}
fmt.Printf("maxVal = %v, maxValIndex = %v \n", maxVal, maxValIndex)
} ~/go/src/go_code/chapter07/demo02/main go run ./main.go
maxVal = 932, maxValIndex = 2 - 请求出一个数组的和和平均值 for-range
func main(){
var doubleArr2 [10]float64 = [...]float64 {1,2,3,4,5,6,7,8,9,10}
var sum float64 = 0
for _, val := range doubleArr2 {
sum += val
}
var avg = sum / (float64)(len(doubleArr2))
fmt.Printf("sum = %v avg = %v\n", sum, avg)
} ~/go/src/go_code/chapter07/demo02/main go run ./main.go
sum = 55 avg = 5.5- 要求：随机生成五个数，并将其反转打印，复杂应用。
package main
import (
"fmt"
"time"
"math/rand"
)
func main(){
var intArr3 [5]int
len := len(intArr3)
rand.Seed(time.Now().UnixNano())
for i := 0; i < len; i++ {
intArr3[i] = rand.Intn(100)
}
fmt.Println("交换前：",intArr3)
//反转打印
temp := 0
for i := 0; i < len / 2; i++ {
temp = intArr3[len-1-i]
intArr3[len-1-i] = intArr3[i]
intArr3[i] = temp
}
fmt.Println("交换后：",intArr3)
} ~/go/src/go_code/chapter07/demo02/main go run ./main.go
交换前： [76 85 22 96 35]
交换后： [35 96 22 85 76]
~/go/src/go_code/chapter07/demo02/main go run ./main.go
交换前： [8 60 13 96 46]
交换后： [46 96 13 60 8]为什么需要切片
需求
我们需要一个数组用于保存学生的成绩，但是学生的个数是不确定的，怎么办？ 答案：使用切片
切片的基本介绍
切片的英文是 slice
切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
切片的使用和数组类似，遍历切片、访问切片的元素和求切片长度 len(slice)都一样。
切片的长度是可以变化的，因此切片是一个可以动态变化数组。
切片定义的基本语法:
//var 切片名 []类型 //比如 var a []int
快速入门
演示一个切片的基本使用：
func main(){
var intArr [5]int = [...]int{1,22,33,66,99}
//声明/定义一个切片
//slice := intArr[1:3]
//1. slice就是切片名
//2. intArr[1:3]表示slice引用到intArr这个数组
//3. 引用intArr数组的起始下标为1，最后的下标为3（但是不包含3）
slice := intArr[1:3]
fmt.Println("intArr:", intArr)
fmt.Println("slice 的元素是 :", slice) // 22 33
fmt.Println("slice的元素个数:", len(slice)) // 2
fmt.Println("slice的容量:",cap(slice)) // 切片的容量是可以动态变化的
} ~/go/src/go_code/chapter07/demo03/main go run ./main.go
intArr: [1 22 33 66 99]
slice 的元素是 : [22 33]
slice的元素个数: 2
slice的容量: 4切片在内存中形式（重要）
基本介绍
为了让大家更加深入的理解切片，我们画图分析切片在内存中是如何布局的，这是一个非常重要的知识点：（以前面的案例来分析）
画出前面的切片内存布局
对上面的分析图总结
- slice的确是一个引用类型
- slice从底层来说，其实就是一个数据结构（strcut结构体）
type slice struct { ptr *[2]int len int cap int }
切片的使用
方式1
第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例就是这样的。
var arr [5]int = [...]int{1,2,3,4,5} var slice = arr[1:3] fmt.Println("arr:", arr) fmt.Println("slice 的元素是 :", slice) fmt.Println("slice的元素个数:", len(slice)) fmt.Println("slice的容量:",cap(slice))方式2
第二种方式：通过make来创建切片
基本语法：
var 切片名 []type = make([]type,len,[cap])参数说明：type就是数据类型，len是大小，cap是指定切片容量，可选，如果你分配了cap，则要求cap>=len
var slice []float64 = make([]float64, 5, 10) slice[1] = 10 slice[3] = 20 //对于切片，必须make使用 fmt.Println(slice) fmt.Println("slice的size=", len(slice)) fmt.Println("slice的cap=", cap(slice))
对上面代码的小结：
- 通过make方式创建切片可以指定切片的大小和容量
- 如果没有给切片的各个元素赋值，那么就会使用默认值【int, float =>0 string=>”” bool=>false】
- 通过make方式创建的切片对应的数组是由make底层维护，对外不可见，即只能通过slice去访问各个元素。
方式3
第三种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式
案例演示：
//方式3 //第3种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式 var strSlice []string = []string{"tom", "jack", "mary"} fmt.Println("strSlice = ", strSlice) fmt.Println("strSlice size = ",len(strSlice)) fmt.Println("strSlice cap = ", cap(strSlice))方式1和方式2的区别（面试）
方式1是直接引用数组，这个数组是事先存在的，程序员是可见的。
方式2是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。make创建切片的示意图：
切片的遍历
切片的遍历和数组一样，也有两种方式
- for循环常规方式遍历
- for-range结构遍历切片
func main(){
var arr[5]int = [...]int{10, 20, 30, 40, 50}
slice := arr[1:4] // 20,30,40
for i := 0; i < len(slice); i++ {
fmt.Printf("slice[%v] = %v\t", i, slice[i])
}
fmt.Println()
for i,v := range slice {
fmt.Printf("i = %v, v = %v\t", i, v)
}
fmt.Println()
} ~/go/src/go_code/chapter07/demo04/main go run ./main.go
slice[0] = 20 slice[1] = 30 slice[2] = 40
i = 0, v = 20 i = 1, v = 30 i = 2, v = 40切片的使用的注意事项和细节讨论
切片初始化时 var slice = arr[startIndex:endIndex]
说明:从 arr 数组下标为 startIndex，取到 下标为 endIndex 的元素(不含 arr[endIndex])。切片初始化时，仍然不能越界。范围在 [0-len(arr)] 之间，但是可以动态增长.
var slice = arr[0:end] <=> var slice = arr[:end] var slice = arr[start:len(arr)] <=> var slice = arr[start:] var slice = arr[0:len(arr)] <=> var slice = arr[:]cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者 make一个空间供切片来使用
切片可以继续切片【演示】
func main(){ var arr[5]int = [...]int{10, 20, 30, 40, 50} slice := arr[1:4] // 20,30,40 for i := 0; i < len(slice); i++ { fmt.Printf("slice[%v] = %v\t", i, slice[i]) } fmt.Println() for i,v := range slice { fmt.Printf("i = %v, v = %v\t", i, v) } fmt.Println() //定义slice2 slice2 := slice[1:2] // slice [ 20, 30, 40] [30] slice2[0] = 100 // 因为arr， slice和slcie2指向的数据空间是同一个，因此slice2[0]=100 fmt.Println("slice2 = ", slice2) fmt.Println("slice = ",slice) fmt.Println("arr = ", arr) }用append内置函数，可以对切片进行动态追加
var slice3 []int = []int(100,200,300) //通过append直接给slice3追加具体的元素 slice3 = append(slice3,400,500,600) fmt.Println("slice3="，slice3) // 100 200 300 400 500 600 //通过append将切片slice3追加给slice3 slice3 = append(slice3, slice3...)//100 200 300 400 500 600 100 200 300 400 500 600 fmt.Println("slice3 append slice3 = ", slice3)对上面的代码的小结
切片append操作的底层原理分析：
切片append操作的本质就是对数组扩容
go 底层会创建一下新的数组newArr(安装扩容后大小)
将 slice 原来包含的元素拷贝到新的数组 newArr
slice 重新引用到 newArr
注意 newArr 是在底层来维护的，程序员不可见.切片的拷贝操作
切片使用copy内置函数完成拷贝，举例说明
var slice4 []int = []int(1,2,3,4,5) var slice5 = make([]int, 10) copy(slice5, slice4) fmt.Println("slice4=", slice4)// 1 , 2, 3 , 4 , 5 fmt.Println("slice5=", slice5)// 1 ,2, 3,4,5,0,0,0,0,0对上面代码的说明：
- copy(para1, para2) 参数的数据类型是切片
- 按照上面的代码来看, slice4 和 slice5 的数据空间是独立，相互不影响，也就是说 slice4[0]= 999,slice5[0] 仍然是 1
关于拷贝的注意事项
- 下面的代码又没有错误？
var a []int = []int {1,2,3,4,5} var slice = make([]int,1) fmt.Println(slice)// [0] copy(slice,a) fmt.Println(slice)**上面的代码没有问题，可以运行，最后输出的是[1]
切片是引用类型，所以在传递时，遵守引用传递机制。看两段代码，并分析底层原理
string和slice
- string底层是一个byte数组，因此string也可以进行切片处理案例演示:
func main() {
//string底层是一个byte数组，因此string也可以进行切片处理
str := "hello@atguigu"
//使用切片获取到 atguigu
slice := str[6:]
fmt.Println("slice=",slice)
}- string和切片在内存的形式，以”abcd”画出内存示意图
- string是不可变的，也就是说不能通过str[0]=’z’方式来修改字符串
str[0] = 'z' //编译不会通过，会报错，因为string是不可变的- 如果需要修改字符串，可以先将string -> []byte 或者 []rune -> 修改 -> 重写转成string
//如果需要修改字符串，可以先将string -> []byte 或者 []rune -> 修改 -> 重写转成string
//"hello@atguigu"=>改成"zello@atguigu"
str := "hello@atguigu"
arr1 := []byte(str)
arr1[0] = 'z'
str = string(arr1)
fmt.Println("str=",str)
//细节，我们转成[]byte后，可以处理英文和数字，但是不能处理中文
//原因：[]byte字节来处理string中的字符，而一个汉子是3个字节，因此会出现乱码
//解决方法：将string转成[]rune即可，因为[]rune是按字符处理，兼容汉字
arr1 := []rune(str)
arr1[0] = '北'
str = string(str)
fmt.Println("str=",str)切片的课堂练习
题目：编写一个函数fbn(n int)，要求完成
- 可以接收一个 n int
- 能够将斐波那契的数列放到切片中
- 提示, 斐波那契的数列形式:
arr[0] = 1; arr[1] = 1; arr[2]=2; arr[3] = 3; arr[4]=5; arr[5]=8
- 代码+思路：
package main
import (
"fmt"
)
func fbn(n int) ([]uint64) {
//声明一个切片，切片大小n
fbnSlice := make([]uint64, n)
//第一个数和第二个数的斐波那契数为1
fbnSlice[0] = 1
fbnSlice[1] = 1
//进行for循环存放斐波那契数列
for i:=2; i < n; i++ {
fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2]
}
return fbnSlice
}
func main(){
fnbSlice := fbn(20)
fmt.Println("fnbSlice=", fnbSlice)
} ~/go/src/go_code/chapter07/demo04/main go run ./main.go
fnbSlice= [1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765]