为什么需要数组
我们来看一个问题：
一个养鸡场有 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 ", totalWeight, avgWeight) }
运行结果如下：
对上面的代码说明：
1、使用传统的方法不利于数据的管理和维护
2、传统的方法不够灵活，因此我们引出需要学习的新的数据类型
数组介绍
package main import "fmt" func main() { //使用数组的方式来解决问题 //1.定义一个数组 var hens [7]float64 //2.给数组的每个元素赋值， 元素的下标是从0开始的 0-5 hens[0] = 3.0 //hens数组的第一个元素 hens[0] hens[1] = 5.0 //hens数组的第2个元素 hens[1] hens[2] = 1.0 hens[3] = 3.4 hens[4] = 2.0 hens[5] = 50.0 hens[6] = 150.0 //增加一只鸡 //3.遍历数组求出总体重 totalWeight2 := 0.0 for i := 0; i < len(hens); i++ { totalWeight2 += hens[i] } //4.求出平均体重 avgWeight2 := fmt.Sprintf("%.2f", totalWeight2 / float64(len(hens))) fmt.Printf("totalWeight2=%v avgWeight2=%v", totalWeight2, avgWeight2) }
上面代码的好处：
1、使用数组来解决问题，程序的可维护性增加
2、而且方法代码更加清晰，也容易扩展。
数组的定义和内存布局
数组的定义
var 数组名 [数组大小]数据类型 var a [5]int 赋初值 a[0] = 1 a[1] = 30 ....
数组在内存布局
我们先声明一个数组：
package main import "fmt" func main() { var intArr [3]int //int占8个字节 //当我们定义完数组后，其实数组的各个元素有默认值 0 fmt.Println(intArr) }
1、数组的地址可以通过数组名来获取 &intArr
2、数组的第一个元素的地址，就是数组的首地址
3、数组的各个元素的地址间隔是依据数组的类型决定，比如 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 ", &intArr, &intArr[0], &intArr[1], &intArr[2]) }
运行结果如下：
数组的使用
访问数组元素
数组名[下标] 比如：你要使用 a 数组的第三个元素 a[2]
案例：我们有一个需求，从终端循环输入 5 个成绩，保存到 float64 数组,并输出.
代码如下：
package main import "fmt" func main() { // 从终端循环输入 5 个成绩，保存到 float64 数组,并输出. var score [5]float64 for i := 0; i < len(score); i++ { fmt.Println("请输入第%d个元素的值 ",i+1) fmt.Scanln(&score[i]) } // 变量数组打印 for i := 0; i < len(score); i++ { fmt.Printf("score[%d]=%v ", i, score[i]) } }
运行结果如下：
数组的使用方式2：
按照上面的方法每次都要确保提供的初始值和数组长度一致，一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度，例如：
package main import ( "fmt" ) func main() { var testArray [3]int var numArray = [...]int{1, 2} var nameArray = [...]string{"bingle1", "bingle2", "bingle3"} fmt.Println(testArray) //[0 0 0] fmt.Println(numArray) //[1 2] fmt.Printf("type of numArray:%T ", numArray) //type of numArray:[2]int fmt.Println(nameArray) //[bingle1 bingle2 bingle3] fmt.Printf("type of nameArray:%T ", nameArray) //type of nameArray:[3]string }
结果如下：
数组使用方式3：
我们还可以使用指定索引值的方式来初始化数组，例如:
package main import ( "fmt" ) func main() { a := [...]int{1: 1, 3: 5} fmt.Println(a) // [0 1 0 5] fmt.Printf("type of a:%T ", a) //type of a:[4]int }
数组的遍历
1、for循环，上面的代码有
2、for-range遍历（类似C#里面的foreach，JavaScript中for-in）
代码如下：
// 变量数组打印 //for i := 0; i < len(score); i++ { // fmt.Printf("score[%d]=%v ", i, score[i]) //} for k, v := range score { fmt.Printf("i=%v v=%v ", k , v) fmt.Printf("heroes[%d]=%v ", k, score[k]) }
执行结果如下：
说明：
1、第一个返回值 k 是数组的下标
2、第二个 v 是该下标位置的值
3、他们都仅在for循环内部可见的局部变量
4、遍历数组元素的时候，如果不想使用下标 k，可以把下标 k 换成_
5、k 和 v名称是不固定的，即程序员可以自行指定。有时候也用index 和 value
数组使用的注意事项与细节
1、数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化
2、var arr []int 这时 arr 就是一个 slice 切片
3、数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
4、数组创建后，如果没有赋值，有默认值(零值)
数值类型数组：默认值为 0
字符串数组：默认值为 ""
bool 数组： 默认值为 false
5、使用数组的步骤：
1. 声明数组并开辟空间 2 给数组各个元素赋值(默认零值) 3 使用数组
6、数组的下标是从 0 开始的，（这点很好理解，程序员的世界，是从 0 开始的）
7、数组下标必须在指定范围内使用，否则报 panic：数组越界，比如：var arr [5]int 则有效下标为 0-4
8、Go 的数组属值类型， 在默认情况下是值传递， 因此会进行值拷贝。数组间不会相互影响
9、如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)
package main import "fmt" func test(arr *[3]int) { (*arr)[2]=88 } func main() { arr := [3]int{11,22,33} test(&arr) fmt.Println(arr) }
执行结果如下：将最后一个元素的值，改成了88
10、长度是数组类型的一部分，在传递函数参数时 需要考虑数组的长度
下面看一个数组的使用案例
要求：随机生成五个数，并将其反转打印
我们的思路：
1、随机生成五个数 , rand.Intn() 函数
2、当我们得到随机数后，就放到一个数组 int数组
3、反转打印 , 交换的次数是 len / 2, 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换
代码如下：
package main import ( "fmt" "math/rand" "time" ) func main() { var intArr [5]int len := len(intArr) // 为了每次生成的随机数不一样，我们需要给一个seed值 rand.Seed(time.Now().UnixNano()) for i := 0; i < len; i++ { intArr[i] = rand.Intn(100) // 0<=n<100 ==>[0,100) } fmt.Println("交换前~=", intArr) // 反转打印 , 交换的次数是 len / 2, // 倒数第一个和第一个元素交换, 倒数第2个和第2个元素交换 temp := 0 // 做一个临时变量 for i := 0; i < len / 2; i++ { temp = intArr[len - 1 - i] intArr[len - 1 - i] = intArr[i] intArr[i] = temp } fmt.Println("交换后~=", intArr) }
运行下结果，如下：
切片
切片的基本介绍
var 切片名 []类型 比如：var a [] int
快速入门
下面看一个切片的基本使用
package main import ( "fmt" ) func main() { var intArr [5]int = [...]int{1, 22, 33, 66, 99} //声明/定义一个切片 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)) // 切片的容量是可以动态变化 }
运行结果如下：
为什么slice 的容量是 4呢？
我们来看一下，切片的本质：
切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。
举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。
切片s2 := a[3:6]，相应示意图如下：
切片的使用
方式1：定义一个切片，然后让切片去引用一个已经创建好的数组，
func main() { var intArr [5]int = [...]int{1, 22, 33, 66, 99} //声明/定义一个切片 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)) // 切片的容量是可以动态变化 }
1、slice是一个引用类型
2、slice 从底层来说，其实就是一个数据结构(struct 结构体)
type slice struct { ptr *[2]int len int cap int }
方式2：通过 make 来创建切片.
package main import "fmt" func main() { var slice []float64 =make([]float64,5,10) slice[1] = 10 slice[3] =30 fmt.Println(slice) fmt.Println("slice 的 size = ",len(slice)) fmt.Println("slice 的 cap = ",cap(slice)) fmt.Printf("slice 的 地址 = %p ",&slice) fmt.Printf("slice 的 ptr = %p ",slice) }
执行结果如下：
对上面代码小结：
1、通过 make 方式创建切片可以指定切片的大小和容量
2、如果没有给切片的各个元素赋值，那么就会使用默认值[int , float=> 0 string =>”” bool =>false]
3、通过 make 方式创建的切片对应的数组是由 make 底层维护，对外不可见，即只能通过 slice 去访问各个元素.
方式3：定义一个切片，直接就指定具体数组，使用原理类似 make 的方式
package main import "fmt" func main() { var strSlice []string = []string{"bingle1","bingle2","bingle3"} fmt.Println("strSlice = ",strSlice) fmt.Println("strSlice size = ",len(strSlice)) // 3 fmt.Println("strSlice cap = ",cap(strSlice)) // ? }
执行结果：
方式 1 和方式 2 的区别：
方式 1 是直接引用数组，这个数组是事先存在的，程序员是可见的
方式 2 是通过make来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。
make创建切片的示意图：
切片的遍历
1、for 循环常规方式遍历
2、for-range 结构遍历切片
1、切片初始化时 var slice = arr[startIndex:endIndex]
2、切片初始化时，仍然不能越界。范围在 [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[:]
3、cap 是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。
4、切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者 make 一个空间供切片来使用
5、切片可以继续切片
package main import "fmt" func main() { var arr [5]int = [...]int{10,20,30,40,50} fmt.Println(arr) slice := arr[1:4] for i := 0; i < len(slice); i++ { fmt.Printf("slice[%v] = %v ;",i,slice[i]) } slice2 := slice[1:2] slice2[0] = 100 fmt.Println("slice2 = ",slice2) fmt.Println("slice = ",slice) fmt.Println("arr = ",arr) }
运行结果如下：
slice2[0] = 100之后，为什么相应的 arr 和slice 的值都变成了100？
因为，arr、slice、slice2 指向的数据空间是同一个
6、用 append 内置函数，可以对切片进行动态追加
package main import "fmt" func main() { var slice []int = []int{100,200,300} fmt.Println(slice) slice = append(slice,400,500,600) fmt.Println(slice) // 通过append将切片slice追加给slice slice = append(slice,slice...) fmt.Println(slice) }
执行结果如下：
切片append操作的底层原理分析：
切片 append 操作的本质就是对数组扩容。go 底层会创建一下新的数组 newArr(安装扩容后大小)。将 slice 原来包含的元素拷贝到新的数组 newArr。slice 重新引用到 newArr。注意 newArr 是在底层来维护的，程序员不可见
7、切片的拷贝操作
package main import "fmt" func main() { var slice []int = []int{1,2,3,4,5} var slice2 = make([]int,10) copy(slice2,slice) fmt.Println("slice = ",slice) fmt.Println("slice2 = ",slice2) }
对上述代码说明：
1、copy(para1, para2) 参数的数据类型是切片
2、按照上面的代码来看, slice 和 slice2 的数据空间是独立，相互不影响，也就是说 slice[0]= 999,slice2[0] 仍然是 1
9、切片是引用类型，所以在传递时，遵守引用传递机制
string和slice
package main import "fmt" func main() { str := "binglezhendeyoudianyisiao" slice := str[6:] fmt.Println(slice) }
2、string 和切片在内存的形式，以 "abcd" 画出内存示意图
3、string 是不可变的，也就说不能通过 str[0] = 'z' 方式来修改字符串
package main import "fmt" func main() { str := "binglezhendeyoudianyisiao" arr := []byte(str) arr[0]='z' str = string(arr) fmt.Println("str = ",str) }
下面我们来实现一个斐波那锲函数：
package main import "fmt" func fbn(n int) []uint64 { if n <= 0 { return nil } // 声明一个切片，切片大小为 n fbnSlice := make([]uint64, n) if n == 1 { fbnSlice[0] = 1 return fbnSlice } if n == 2 { fbnSlice[0] = 1 fbnSlice[1] = 1 return fbnSlice } fbnSlice[0] = 1 fbnSlice[1] = 1 for i := 2; i < n; i++ { fbnSlice[i] = fbnSlice[i-1] + fbnSlice[i-2] } return fbnSlice } func main() { arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} fmt.Println(arr) fbnSlice := fbn(20) fmt.Println("fbnSlice = ", fbnSlice) }
