Go第 7 章：数组与切片

7.1 为什么需要数组

7.2 数组介绍

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

7.3 数组的快速入门

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

7.4 数组定义和内存布局

对上图的总结:
1）数组地址可以通过数组名来获取 &intArr
2）数组的第一个元素的地址，就是数组的首地址
3）数组的各个元素的地址间隔是依据数组的类型决定，比如int64->8 int32->4…
4）定义好一个数组但未赋值，则默认值为0

7.5 数组的使用

 访问数组元素
数组名[下标] 比如：你要使用 a 数组的第三个元素 a[2]
 快速入门案例
从终端循环输入 5 个成绩，保存到 float64 数组,并输出.

7.6 数组的遍历

7.6.1方式 1-常规遍历:

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

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

这是 Go语言一种独有的结构，可以用来遍历访问数组的元素。

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

1. 数组是多个相同类型数据的组合,一个数组一旦声明/定义了,其长度是固定的, 不能动态变化
   
   2）var arr []int 这时arr就是一个slice切片，切片后面专门讲解，不急
   3）数组中的元素可以是任何数据类型，包括值类型和引用类型，但是不能混用
   4）数组创建后，如果没有赋值，默认为0

数值类型数组：默认值为 0
字符串数组： 默认值为 “”
bool 数组： 默认值为 false


5）使用数组的步骤 1、声明数组并开辟空间2、给数组各个元素赋值（默认为0）3、使用数组
6) 数组的下标是从 0 开始的
7) 数组下标必须在指定范围内使用，否则报 panic：数组越界，比如
var arr [5]int 则有效下标为 0-4
8) Go 的数组属值类型， 在默认情况下是值传递， 因此会进行值拷贝。数组间不会相互影响

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

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

• []int 为切片类型而[3]int为数组.
• 认为[3]int是一种数据类型 [4]int是另一种数据类型

7.8 数组的应用案例

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

func main() {
	var mychars [26]byte
	mychars[0]= 'A'
	for i:=1;i<len(mychars);i++{
		mychars[i]= mychars[i-1]+byte(1)
	}
	for i:=0;i<len(mychars);i++{
		fmt.Printf("mychars[%d]=%c\n",i,mychars[i])
	}
	fmt.Println(mychars)
}

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

func main() {
	var compare [6]int = [...]int{1, -1, 9, 90, 11, 9000}
	maxVal := compare[0]
	maxValIndex := 0

	//for i := 1; i < len(compare); i++ {
	//	if maxVal < compare[i] {
	//		maxVal = compare[i]
	//		maxValIndex = i
	//	}
	//}
	for i, j := range compare {
		if maxVal < j {
			maxVal = j
			maxValIndex = i
		}
	}
	fmt.Printf("maxVal = %v,maxValIndex=%v", maxVal, maxValIndex)
}

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

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

7.9 为什么需要切片

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

7.10 切片的基本介绍

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

7.11 快速入门

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

cap 可能是 len的两倍或者1.5倍不用关心

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

对上面的分析图总结

1. slice 的确是一个引用类型
2. slice 从底层来说，其实就是一个数据结构(struct 结构体)
   type slice struct {
   ptr *[2]int len int cap int
   }

7.13 切片的使用

• 方式1
  第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例就是这 样的。
  
• 方式 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的方式
  

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

7.14 切片的遍历

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

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

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 一
   个空间供切片来使用

4. 切片可以继续切片[案例演示]
   

5. 用 append 内置函数，可以对切片进行动态追加
   
   对上面代码的小结
   
   切片 append操作的底层原理分析:
   切片 append 操作的本质就是对数组扩容
   go 底层会创建一下新的数组 newArr(安装扩容后大小)
   将 slice原来包含的元素拷贝到新的数组 newArr slice 重新引用到 newArr
   注意 newArr 是在底层来维护的，程序员不可见.

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

对上面代码的说明:
(1) copy(para1, para2) 参数的数据类型是切片
(2) 按照上面的代码来看, slice4 和 slice5 的数据空间是独立，相互不影响，也就是说 你改变了slice4[0]= 999,但是slice5[0] 仍然是 1

8. 关于拷贝的注意事项
   
   说明: 上面的代码没有问题，可以运行, 最后输出的是 [1]

9. 切片是引用类型，所以在传递时，遵守引用传递机制。看两段代码，并分析底层原理
   

7.16 string 和 slice

1. string 底层是一个 byte 数组，因此 string 也可以进行切片处理 案例演示：
   
2. string 和切片在内存的形式，以 “abcd” 画出内存示意图
   

3) string 是不可变的，也就说不能通过 str[0] = ‘z’ 方式来修改字符串

4) 如果需要修改字符串，可以先将 string -> []byte / 或者 []rune -> 修改 -> 重写转成 string

7.17 切片的课堂练习题

说明：编写一个函数 fbn(n int) ，要求完成

1. 可以接收一个 n int 2) 能够将斐波那契的数列放到切片中 3) 提示, 斐波那契的数列形式:
   arr[0] = 1; arr[1] = 1; arr[2]=2; arr[3] = 3; arr[4]=5; arr[5]=8

代码+思路：

func fbn(n int) []uint64 {
	fbnSlice := make([]uint64, n)
	fbnSlice[0] = 1
	fbnSlice[1] = 1
	for i := 2;i<n;i++{
		fbnSlice[i]=fbnSlice[i-1]+fbnSlice[i-2]
	}
	return fbnSlice
}

func main() {
	fbnSlice := fbn(20)
	fmt.Println(fbnSlice)
}