4.6 数组与切片
4.6.1数组
数组可以存放多个同一类型数据。数组也是一种数据类型，在Go中，数组是值类型。
数组的定义：var 数组名 [数组大小]数据类型
数组的内存布局：1）数组的地址可以通过数组名来获取&intArr。2）数组第一个元素的地址，就是数组的首地址。3）数组的各个元素的地址间距是依据数的类型决定的，比如int64->8、int32->4…
数组的使用：1）访问数组元素，直接数组名[下标]。
2）从终端输入数据保存到数组中
3）四种初始化数组的方式
//四种初始化数组的方式
var numArr1 [3]int = [3]int{1,2,3}
var numArr2 = [3]int{4,5,6}
var numArr3 = [...]int{8,9,10}
var numArr4 = [...]int{0:11,1:12,2:13}
var strArr5 = [...]string{1:"tom",2:"jack",0:"ross"}
fmt.Println(numArr1,numArr2,numArr3,numArr4,strArr5)
//终端输入数据保存到数组
var score [5]float64
for i := 0; i < len(score); i++ {
fmt.Printf("请输入第%d个元素的值", i+1)
fmt.Scanln(&score[i])
}
//打印数组
for i := 0; i < len(score); i++ {
fmt.Printf("score[%d]=%v", i, score[i])
}
数组的遍历：
1）常规遍历len(arr)。2）for-range遍历：for index,value：= range arr{}
range函数中第一个返回值index是数组的下标，第二个value是在该下边位置的值，都是在for循环内部可见的局部变量，遍历时不想使用下标index，可以直接标为下划线_，index和value的名称可以自行设计。
数组细节：
1）数组是由多个相同类型数据的组合，一旦一个数组定义了，其长度是固定的，不能够再动态变化，且定义了int类型的数组就不能传入float类型的数据。
2）var arr []int表示可变长度的数组，此时arr就是一个slice切片
3）数组中的元素可以是任何数据类型，包括值类型和引用类型
4）数组创建后没有主动赋值，将使用默认值{0，“”，false}
5）数组步骤：声明数组开辟空间–>给数组各个元素赋值–>使用数组
6）数组下标是从0开始的，且下标必须再指定范围内，否则报panic：数组越界
7）数组属于值类型，在默认情况下是值传递，因此会进行值拷贝，数组间不会互相影响，而如果在其他函数中去修改原来的数组，可以使用引用传递。
func shuzu_test01(arr [3]int) {
arr[0] = 80
for _, value := range arr {
fmt.Println(value)
}
}
func shuzu_test02(arr *[3]int) {
arr[0] = 80
for _, value := range arr {
fmt.Println(value)
}
}
var arr = [...]int{1, 2, 3}
shuzu_test01(arr)
for _, value := range arr {
fmt.Println(value)
}
shuzu_test02(&arr)
for _, value := range arr {
fmt.Println(value)
}
/*使用test01值传递，输出80，2，3 1，2，3*/
/*使用test02引用传递，输出80，2，3 80，2，3*/
8）函数调用时需要注意传递的数组长度，不能把[3]int传递给[]int，也不能传递给[4]int
4.6.2 切片
切片slice 是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用类型的传递机制。
2）切片的使用和数组类似，遍历切片、访问切片元素和求切片长度len(slice)都一样。
3）切片的长度是可以变化的，因此切片是一个可以动态变化数组
4）切面定义的基本语法：var 切片名 []类型
切片在内存中形式：从底层而言就相当于一个结构体，包含ptr*、长度、和容量。可以发现&slice和&arr对应位置相同。修改slice的值，修改slice的值，其对应数组的值也会发生改变。
切片使用的三种方式：
1）定义一个切片，然后让切片引用一个已经创建好的数组。
2）通过make来创建切片，基本语法：var 切片名[]type = make([],len,[cap])其中type就是数据类型，len:大小，cap：指定切片容量【可选】
区别：通过make创建的slice只能由slice去访问，对外不可见。
3）定义一个切片，直接就指定具体的数组，类似make的方式。
//方式一：声明/定义一个切片
//slice就是切片名，int[1:3]表示slice引用到intArr这个数组
slice := intArr[1:3] //引用intArr的起始下标为1，最后的下标为3(不包含3)，表示[1,3）
fmt.Println("原数组为", intArr)
fmt.Println("切片元素为", slice)
fmt.Println("slice的元素个数是", len(slice))
fmt.Println("slice的容量是", cap(slice)) //切片的容量是可以动态变化的,数组没有容量的概念。
/*原数组为 [1 22 33 66 99]
切片元素为 [22 33]
slice的元素个数是 2
slice的容量是 4 */
//slice在内存中的地址
fmt.Printf("intArr[1]的地址是%p", &intArr[1])
fmt.Printf("slice[0]的地址是%p,slice[0]的值为%v", &slice[0], slice[0])
//方式二：通过make来创建切片,make:分配并初始化一个类型为切片，映射或者通道的对象，第一个参数为类型，第二个为size,容量必须>=长度
var slice_2 []int = make([]int, 4, 10)
// 省略cap表示为var slice_2 []int = make ([]int, 4 )
//此时创建的数组，程序员只能通过slice查看，不能再通过数组查看
fmt.Println(slice_2) //默认值为0
//方式三：定义切片直接指定具体的数组
var slice_3 []string = []string{"tom", "jake", "mary"}
fmt.Println("切片元素为", slice_3)
fmt.Println("slice的元素个数是", len(slice_3))
fmt.Println("slice的容量是", cap(slice_3))
切片的遍历
遍历方式和数组一样有两种方式：
1）使用常规for循环遍历。2）for-range遍历
//遍历切片
for i := 0; i <= len(slice); i++ {
fmt.Printf("%v", slice[i])
}
//for-range遍历
for index, value := range slice {
fmt.Printf("%v,%v", index, value)
}
切片细节：
1）切片初始化时 var slice = arr[startindex:endindex]中，从arr数组下标为startIndex取到endindex但不包含endindex。
var slice = arr[0:end]简写成 arr[:end]
arr[start:len(arr)]简写成arr[start:]
arr[0:len(arr)]简写成arr[:]
2）切片初始化时，仍然不能越界【不能超过endindex】，但是可以动态增长。
3）cap是一个内置函数，用于统计切片的容量即最大可以存放多少个元素。切片定义完之后还不能直接使用【空指针】,需要让其引用到一个数组或者make一个空间供切片使用
4）切片可以继续切片。需要注意下标对应以及所有关联值的变化。
5）切片的动态增长，使用append内置增长：将元素追加到切片末尾。底层分析：切片append 操作的本质就是对数组扩容，go底层会创建新的数组newArr(安装扩容后大小)，将slice原来包含的元素拷贝到新的数组newArr，slice重新引用到newArr，原数组销毁。注意newArr是在底层来维护的，程序员不可见。
var slice_1 []int = []int{100, 200, 300}
//给slice_1追加400,500
slice_1 = append(slice_1, 400, 500)
//通过append追加slice3给slice3,...相当于解构，后面只能是切片不能够时数组。
slice_1 = append(slice_1, slice_1...)
var slice_2 []int = make([]int, 10)
fmt.Println(slice_2)
copy(slice_2, slice_1)
fmt.Println(slice_2)
6）切片的拷贝操作，使用copy（para1,para2）：将p2的元素拷贝给p1，其中p1,p2都是切片类型，两个切片都有自己的空间，因此数据互不影响。如果p2>p1则会将p1补满，不会发生错误。
7）在test（slice []int）函数中修改slice会直接影响实参（引用传递）
string 和slice：
1）string底层时byte数组，因此string也可以进行切片处理。可以说string的底层和切片类似。
2）string 本身不可变的，不能通过str[0]='z’来修改字符串。修改字符串需要先将string转换成[]byte切片或者[]rune，在进行修改，重写转成string
str := "hello@xzc_11-17"
str_slice := str[6:]
fmt.Println(str_slice)
//修改str中单个字符
arr1 := []byte(str)//强转
arr1[0] = 'z'
str = string(arr1)//强转
//由于[]byte是按照字节处理，因此不能够处理汉字，汉字是3个字节
//汉字需要将 string 转成 []rune ,rune按照字符处理
arr2 := []rune(str)
arr2[2] = '北'
str = string(arr2)