【Go笔记】第 7 章 数组与切片

• 【尚硅谷】Golang入门到实战教程丨一套精通GO语言 (opens new window)笔记，可在Bilibili同步观看
• 尚硅谷-视频观看地址 (opens new window)

7.1 为什么需要数组

🏷 看一个问题 一个养鸡场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。请问这六只鸡的总体重是 多少?平均体重是多少? 请你编一个程序。=》数组

🏷使用传统的方法来解决

package main  
  
import "fmt"  
  
func main() {  
   //一个养鸡场有6只鸡，它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50kg。请问这六只鸡的总体重是多少？平均体重是多少？请你编一个程序。=》数组  
   //思路分析：定义六个变量，分别表示六只鸡的，然后求出和，然后求出平均值。  
   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  
   //fmt.sprintf("%.2f",tota1 weight/6)将totalweight/6四舍五入保留到小数点2返回值  
   avgweight := fmt.Sprintf("%.2f", totalweight/6)  
   fmt.Printf("totalweight=%v avgWeight=%v", totalweight, avgweight)  
}

对上面代码的说明

1. 使用传统的方法不利于数据的管理和维护.
2. 传统的方法不够灵活，因此我们引出需要学习的新的数据类型=>数组.

7.2 数组介绍

数组可以存放多个同一类型数据。数组也是一种数据类型，在 Go 中，数组是值类型。

7.3 数组的快速入门

我们使用数组的方法来解决养鸡场的问题.

package main  
  
import "fmt"  
  
func main() {  
   //使用数组的方式来解决问题  
   //正定义一个数组  
   var hens [7]float64  
   //2.给数组的每个元素赋值，元素的下标是从©开始的0-5  
   hens[0] = 3.0 //hens数组的第一个元素hens[o]  
   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]  
   }  
  
   //14.求出平均体重  
   avgweight2 := fmt.Sprintf("%.2f", totalweight2/float64(len(hens)))  
   fmt.Printf("totalweight2=%v avgweight2=%v", totalweight2, avgweight2)  
}

对上面代码的总结

1. 使用数组来解决问题，程序的可维护性增加.
2. 而且方法代码更加清晰，也容易扩展。

7.4 数组定义和内存布局

🏷 数组的定义 var 数组名 [数组大小]数据类型 var a [5]int 赋初值 a[0] = 1 a[1] = 30 ....

🏷 数组在内存布局( 重要)

对上图的总结:

1. 数组的地址可以通过数组名来获取 &intArr
2. 数组的第一个元素的地址，就是数组的首地址
3. 数组的各个元素的地址间隔是依据数组的类型决定，比如 int64 -> 8 int32->4...

package main  
  
import "fmt"  
  
func main() {  
   var intArr [3]int //int占8个字节  
  
   //当我们定义完数组后，其实数组的各个元素有默认值日  
   fmt.Println(intArr)  
   intArr[0] = 10  
   intArr[1] = 20  
   intArr[2] = 30  
   fmt.Println(intArr)  
   fmt.Printf("intarr的地址=p intarr[o]地址%p intarr[1]地址%p intArr[2]地址%p",  
      &intArr, &intArr[0], &intArr[1], &intArr[2])  
}

7.5 数组的使用

🏷 访问数组元素 数组名[ 下标] 比如：你要使用 a 数组的第三个元素 a[2]

🏷 快速入门案例 从终端循环输入 5 个成绩，保存到 float64 数组,并输出.

package main  
  
import "fmt"  
  
func main() {  
   //从终端循环输入5个成绩，保存到f1oat64数组，并输出  
   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\n", i, score[i])  
   }  
}

🏷 四种初始化数组的方式

package main  
  
import "fmt"  
  
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("numArre4=", numArr04)  
  
   //类型推导  
   strArr05 := [...]string{1: "tom", 0: "jack", 2: "mary"}  
   fmt.Println("strArr05=", strArr05)  
}

7.6 数组的遍历

7.6.1方式 1-常规遍历:

前面已经讲过了，不再赘述。

7.6.2方式 2-for-range 结构遍历

这是 Go 语言一种独有的结构，可以用来遍历访问数组的元素。 🏷 for--range 的基本语法

🏷 for-range 的案例

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   //演示for-range遍历数组  
   heroes := [...]string{"宋江", "吴用", "卢俊义"}  
  
   //使用常规的方式遍历，我不写了，，  
   for i, v := range heroes {  
      fmt.Printf("i=%vv=%v\n", i, v)  
      fmt.Printf("heroes[%d]=%v\n", i, heroes[i])  
   }  
  
   for _, v := range heroes {  
      fmt.Printf("元素的值=%vn", v)  
   }  
  
}

7.7 数组使用的注意事项和细节

1. 数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   //数组是多个相同类型数据的组合，一个数组一旦声明/定义了，其长度是固定的，不能动态变化。  
   var arr01 [3]int  
   arr01[0] = 1  
   arr01[1] = 30  
   //这里会报错  
   //因为数组的类型是t,就不能给1.1  
   //arr01[2] = 1.1 错误  
   //其长度是固定的，不能动态变化，否则报越界  
   //arr01[3] = 890 错误  
   //数组不能动态增长  
   fmt.Println(arr01)  
}

2. var arr []int 这时 arr 就是一个 slice 切片，切片后面专门讲解，不急哈.
3. 数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用。
4. 数组创建后，如果没有赋值，有默认值(零值)数值类型数组：默认值为 0字符串数组： 默认值为 "" bool 数组： 默认值为 false

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   //数组创建后，如果没有赋值，有默认值（零值）  
   //1.数值（整数系列，浮点数系列）=>8  
   //2.字符串==>  
   //3.布尔类型==>fa1se  
   var arr01 [3]float32  
   var arr02 [3]string  
   var arr03 [3]bool  
   fmt.Printf("arr01=%v arr02=%v arr03=%v\n", arr01, arr02, arr03)  
}

5. 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值(默认零值) 3 使用数组
6. 数组的下标是从 0 开始的

//数组的下标是从0开始的  
var arr04 [3]string //0-2  
var index int = 3  
arr04[index] = "tom" //因为下标是0-2,因此arr04[3]就越界

7. 数组下标必须在指定范围内使用，否则报 panic：数组越界，比如 var arr [5]int 则有效下标为 0-4
8. Go 的数组属值类型， 在默认情况下是值传递， 因此会进行值拷贝。数组间不会相互影响

9. 如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)

10. 长度是数组类型的一部分，在传递函数参数时 需要考虑数组的长度，看下面案例

7.8 数组的应用案例

1. 创建一个 byte 类型的 26 个元素的数组，分别 放置'A'-'Z‘。使用 for 循环访问所有元素并打印出来。提示：字符数据运算 'A'+1 -> 'B'

package main  
  
import "fmt"  
  
func main() {  
   //1)创建一个byte类型的26个元素的数组，分别放置'A'-'z‘。  
   //使用for循环访问所有元素并打印出来。提示：字符数据运算'A'+1->'B'  
   //思路  
   //1.声明一个数组var mychars[26]byte  
   //2.使用for循环，利用字符可以进行运算的特点来赋值'A'+1->'B'  
   //3.使用for打印即可  
   //1代码：  
   var mychars [26]byte  
   for i := 0; i < 26; i++ {  
      mychars[i] = 'A' + byte(i) //注意需要将i=>byte  
      for i := 0; i < 26; i++ {  
         fmt.Printf("%c ", mychars[i])  
      }  
  
   }}

2. 请求出一个数组的最大值，并得到对应的下标。

package main  
  
import "fmt"  
  
func main() {  
   //请求出一个数组的最大值，并得到对应的下标  
   //思路  
   //1.声明一个数组var intArr[5]=[..]int{1,-1,9,90,11)  
   //2.假定第一个元素就是最大值，下标就和  
   //3.然后从第二个元素开始循环比较，如果发现有更大，则交换  
   fmt.Println()  
   var intArr [6]int = [...]int{1, -1, 9, 90, 11, 9080}  
   maxVal := intArr[0]  
   maxValIndex := 0  
   for i := 1; i < len(intArr); i++ {  
      //然后从第二个元素开始循环比较，如果发现有更大，则交换  
      if maxVal == intArr[i] {  
         maxVal = intArr[i]  
         maxValIndex = i  
      }  
      fmt.Printf("maxVal=%v maxValIndex=%v", maxVal, maxValIndex)  
   }  
}

3. 请求出一个数组的和和平均值。for-range

package main  
  
import "fmt"  
  
func main() {  
   //请求出一个数组的和和平均值。for-range  
   //思路  
   //1.就是声明-个数组var intArr[5]=[..]int{1,-1,9,96,11  
   //2.求出和sum  
   //3.求出平均值  
   //1代码  
   var intArr2 [5]int = [...]int{1, -1, 9, 90, 12}  
   sum := 0  
   for val := range intArr2 {  
      //累计求和  
      sum += val  
   }  
   //如何让平均值保留到小数，  
   fmt.Printf("sum=%v=%v", sum, float64(sum)/float64(len(intArr2)))  
}

4. 要求：随机生成五个数，并将其反转打印 , 复杂应用.

package main  
  
import (  
   "fmt"  
   "math/rand"   "time")  
  
func main() {  
   //要求：随机生成五个数，并将其反转打印  
   //思路  
   //1.随机生成五个数，rand.Intn()函数  
   //2.当我们得到随机数后，就放到一个数组int数组  
   //3.反转打印，交换的次数是1en/2,倒数第一个和第一个元素交换，倒数第2个和第2个元素交  
   var intArr3 [5]int  
   //为了每次生成的随机数不一样，我们需要给一个seed值  
   len := len(intArr3)  
  
   rand.Seed(time.Now().UnixNano())  
   for i := 0; i < len; i++ {  
      intArr3[i] = rand.Intn(100) //0<=n<100  
   }  
  
   fmt.Println("交换前~=", intArr3)  
   //反转打印，交换的次数是1en/2,  
   //倒数第一个和第一个元素交换，倒数第2个和第2个元素交换  
   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)  
}

7.9 为什么需要切片

先看一个需求：我们需要一个数组用于保存学生的成绩，但是 学生的个数是不确定的，请问怎么 办？解决方案：-》使用 切片。

7.10 切片的基本介绍

1. 切片的英文是 slice
2. 切片是数组的一个引用，因此 切片是引用类型，在进行传递时，遵守引用传递的机制。
3. 切片的 使用和数组类似，遍历切片、访问切片的元素和求切片长度 len(slice)都一样。
4. 切片的长度是可以变化的，因此切片是一个 可以动态变化数组。
5. 切片定义的基本语法: var 切片名 []类型 比如：var a [] int

7.11 快速入门

演示一个切片的基本使用：

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   //演示切片的基本使用  
   var intArr [5]int = [...]int{1, 22, 33, 66, 99}  
   //声明/定义一个切片  
   //slice :intArr[1:3]  
   //1.s1ice就是切片名  
   //2.intArr[1:3]表示slice引用到intArri这个数组  
   //3.引用intArr数组的起始下标为1，最后的下标为3（但是不包含3）  
   slice := intArr[1:3]  
   fmt.Println("intArr=", intArr)  
   fmt.Println("s1ice的元素是=", slice)       //22,33  
   fmt.Println("slice的元素个数=", len(slice)) //2  
   fmt.Println("slice的容量=", cap(slice))   //切片的容量是可以动态变化  
}

//运行结果
//intArr = [1 22 33 66 99]
//slice 的元素是 = [22 33]
//slice 的元素个数 = 2
//slice 的容量 = 4

7.12 切片在内存中形式(重要)

🏷 基本的介绍： 为了让大家更加深入的理解切片，我们画图分析一下切片在内存中是如何布局的，这个是一个非 常重要的知识点：(以前面的案例来分析)

🏷 画出前面的切片内存布局

🏷 对上面的分析图总结

1. slice 的确是一个引用类型
2. slice 从底层来说，其实就是一个数据结构(struct 结构体)

	type slice struct {
		ptr *[2]int
		len int
		cap int
	}

7.13 切片的使用

🏷 方式 1 第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例就是这样的。

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   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 =", len(slice))  
   fmt.Println("slice cap =", cap(slice))  
}

🏷 方式 2 第二种方式：通过 make 来创建切片. 基本语法：var 名 切片名 []type = make([]type, len, [cap])

参数说明: type: 就是数据类型 len : 大小 cap ：指定切片容量， 可选， ， 如果你分配了 cap, 则要求 cap>=len. 案例演示：

上面代码的小结:

1. 通过 make 方式创建切片可以指定切片的大小和容量
2. 如果没有给切片的各个元素赋值，那么就会使用默认值[int , float=> 0 string =>”” bool =>false]
3. 通过 make 方式创建的切片对应的数组是由 make 底层维护，对外不可见，即只能通过 slice 去 访问各个元素.

🏷 方式 3 第 3 种方式：定义一个切片，直接就指定具体数组，使用原理类似 make 的方式 案例演示：

//方式3
fmt.Println()
//第3种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式
var strslice []string = []string{"tom","jack","mary"}
fmt.Println("strslice=",strslice)
fmt.Println("strslice size=",len(strslice))//3
fmt.Println("strslice cap=",cap(strslice))//?

//输出：
//strslice= [tom jack mary]
//strslice size= 3         
//strslice cap= 3 

🏷 方式 1 和方式 2 的区别(面试)

7.14 切片的遍历

切片的遍历和数组一样，也有两种方式

• for 循环常规方式遍历
• for-range 结构遍历切片

package main  
  
import (  
   "fmt"  
)  
  
func main() {  
   //使用常规的for循环遍历切片  
   var arr [5]int = [...]int{10, 20, 38, 40, 50}  
   slice := arr[1:4] //20,30,40  
  
   for i := 0; i < len(slice); i++ {  
      fmt.Printf("slice[%v]=%v ", i, slice[i])  
   }  
  
   fmt.Println()  
  
   //使用for-range方式遍历切片  
   for i, v := range slice {  
      fmt.Printf("i=%vv=%v In", i, v)  
   }  
}

7.15 切片的使用的注意事项和细节讨论

1. 切片初始化时 var slice = arr[startIndex:endIndex] 说明：从 arr 数组下标为 startIndex，取到 下标为 endIndex 的元素(不含 arr[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. 切片可以继续切片[案例演示]

6. 用 append 内置函数，可以对切片进行动态追加

func main() {  
   //用append内置函数，可以对切片进行动态追加  
   var slice3 []int = []int{100, 200, 300}  
   //通过append直接给slice3追加具体的元素  
   slice3 = append(slice3, 400, 500, 600)  
   fmt.Println("s1ice3", slice3) //100,200,300,400,500,600  
  
   //通过append将切片slice3追加给slice3  
   slice3 = append(slice3, slice3...) //100,200,300,408,500,608100,200,300,400  
   fmt.Println("slice3", slice3)  
}

/**输出
s1ice3 [100 200 300 400 500 600]
slice3 [100 200 300 400 500 600 100 200 300 400 500 600]
**/

对上面代码的小结

切片 append 操作的底层原理分析: 切片 append 操作的本质就是对数组扩容 go 底层会创建一下新的数组 newArr(安装扩容后大小) 将 slice 原来包含的元素拷贝到新的数组 newArr slice 重新引用到 newArr 注意 newArr 是在底层来维护的，程序员不可见.

7. 切片的拷贝操作 切片使用 copy 内置函数完成拷贝，举例说明

func main() {  
   //切片的拷贝操作  
   //切片使用copy内置函数完成拷贝，举例说明  
   fmt.Println()  
   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("s1ice5=", slice5) //1,2,3,4,5,0,8,0,0,0  
}

/**输出
slice4= [1 2 3 4 5]          
s1ice5= [1 2 3 4 5 0 0 0 0 0]
**/

对上面代码的说明:

1. copy(para1, para2) 参数的数据类型是切片
2. 按照上面的代码来看, slice4 和 slice5 的数据空间是独立，相互不影响，也就是说 slice4[0]= 999,`slic