一、数组
1.什么是数组？
1.数组是一系列同一类型数据的集合
2.数组中包含的每个数据被称为数组元素
3.一个数组中包含的元素个数成为数组长度
4.数组的长度是固定的
5.一个数组可以由零个或者多个元素组成
2.数组的申明
var arr [10]int //10个元素的整型数组 var ptrs [5]*float64 //5个元素的指针数组，每个指针都指向float64类型 var points [8]struct{ x, y int } //8个元素的结构体类型 var arry [2][3]int //2*3的二维整型数组 a := [3]int{1, 2, 3} // 长度为3的数组 b := [5]int{1, 2, 3} //长度为10，前三个元素为1、2、3，其它默认为0 c := [...]int{4, 5, 6} //长度3的方式，Go自动计算长度 r := [...]int{9: 6} //长度为10，最后一个元素的值为6，其它默认为0 arr2 := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}//二维数组
在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量表达式。
3.数组的初始化
//申明数组 var a [5]byte //长度为5的数组，每个元素为一个字节 var d [2][3]int //二维数组 //初始化数组 a = {'1','2','3'} d = {{1,2,3},{4,5,6}}
a := [3]byte{'1', '2', '3'} //声明并初始化一个长度为3的byte数组 a := [...]byte{'1', '2', '3'} //可以省略长度而采用`...`的方式，Go会自动根据元素个数来计算长度 d := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}} d := [2][3]int{{1,2,3},{4,5,6}} //如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的 类型
4.数组元素访问
1.可以使用数组下标来访问数组中的元素
2.数组下标从0开始
3.len(arr)-1则表示最后一个元素的下标
package main import ( "fmt" ) func main() { var result int arr := [...]int{1, 2, 3, 4, 5} len := len(arr) //len获取数组长度 fmt.Println("修改前:", arr) arr[0] = 100 //下标访问数组元素 result = arr[3] //取出下标为3的元素并赋值 fmt.Println("修改后:", arr) fmt.Println("数组长度:", len) fmt.Println("方位下标为三的元素：",result) } //运行结果 //修改前: [1 2 3 4 5] //修改后: [100 2 3 4 5] //数组长度: 5 //方位下标为三的元素： 4
package main import( "fmt" ) func main(){ arr := [...]int {9: 1} fmt.Println(arr) fmt.Println(len(arr)) } //运行结果 //[0 0 0 0 0 0 0 0 0 1] //10
package main import( "fmt" ) func main(){ arr := [5]int {1, 2, 3, 4, 5} for i := 0; i < len(arr); i++{ fmt.Printf("arr[%d]=%d ", i, arr[i]) } } //运行结果 //arr[0]=1 //arr[1]=2 //arr[2]=3 //arr[3]=4 //arr[4]=5
package main import( "fmt" ) func main(){ arr := [5]int {1, 2, 3, 4, 5} for i, v := range(arr) { fmt.Printf("arr[%d]=%d ", i, v) } } //运行结果 //arr[0]=1 //arr[1]=2 //arr[2]=3 //arr[3]=4 //arr[4]=5
5.数组的传递
1.数组作为函数的参数仍然是值传递（值传递是复制数组给函数，传递后数组跟原数组没有关系）
2.虽然可以使用数组的指针来代替，但是改变不了数组长度。(可以改变数组内的值，但是不能改变数组的长度)
package main import "fmt" func main() { arr1 := [5]int{1, 2, 3, 4, 5} fmt.Println("交换前arry1= " ,arr1) swap(arr1 ) fmt.Println("交换后arry1= " ,arr1) } func swap(a [5]int) { arr3 := a fmt.Println("值传递交换前arr3= ",arr3) c := arr3[0] arr3[0] = arr3[4] arr3[4] = c fmt.Println("值传递交换后arr3= ",arr3) } //运行结果 //交换前arry1= [1 2 3 4 5] //值传递交换前arr3= [1 2 3 4 5] //值传递交换后arr3= [5 2 3 4 1] //交换后arry1= [1 2 3 4 5]
package main import "fmt" func main() { arr1 := [5]int{1, 2, 3, 4, 5} fmt.Println("交换前arry1= " ,arr1) swap_pointer(&arr1 ) fmt.Println("交换后arry1= " ,arr1) } func swap_pointer(a *[5]int) { var arr3 *[5]int arr3 = a fmt.Println("指针传递交换前arr3= ",arr3) c := arr3[0] arr3[0] = arr3[4] arr3[4] = c fmt.Println("指针传递交换后arr3= ",arr3) } //运行结果 //交换前arry1= [1 2 3 4 5] //指针传递交换前arr3= &[1 2 3 4 5] //指针传递交换后arr3= &[5 2 3 4 1] //交换后arry1= [5 2 3 4 1]
6.数组的比较
1.如果数组元素的类型是可比较的，那么这个数组也是可的比较
2.只有数组的所有元素都相等数组才是相等的。
3.由于长度也是数组类型的一部分，所以长度不同的数组是不等的。
4.数组可遍历、可修改，是否可比较，由数组元素决定。
5.%T用于显示一个值对应的数据类型。
7.数组的局限性
1.数组的长度在定义之后无法修改。
2.数组是值类型，每次传递都将产生一份副本。
3.显然这无法满足开发者的某些需求。
二、切片（slice）
1.什么是切片？
1.切片（Slice）是一个拥有相同类型元素的可变长度的序列。
2.Go语言切片的内部结构包含地址、大小和容量。
3.切片一般用于快速地操作一块数据集合。
4.slice 总是指向底层的一个 array。
5.slice本身不是数组，slice 是一个指向 array的指针。
切片结构和内存分布示意图
2. 从数组或者一个切片中生成一个切片
slice [开始位置:结束位置:容量]
a. slice 表示目标切片对象
b. 开始位置对应目标切片对象的索引
c. 结束位置对应目标切片的结束索引
package main import "fmt" func main() { var a = [5]int{1,2,3} var c []int c = a[1:4:5] fmt.Println("c的长度为：%d",len(c)) fmt.Println("c的容量为：%d",cap(c)) fmt.Printf("c的类型：%T",c) } //运行结果 //c的长度为：%d 3 //c的容量为：%d 4 //c的类型：[]int
从数组或切片生成新的切片拥有如下特性
a.取出的元素数量为：结束位置-开始位置
b.取出元素不包含结束位置对应的索引，切片最后一个元素使用 slice[len(slice)] 获取
c.当缺省开始位置时，表示从连续区域开头到结束位置
d.当缺省结束位置时，表示从开始位置到整个连续区域末尾
e.两者同时缺省时，与切片本身等效
f.两者同时为0时，等效于空切片，一般用于切片复位
(ps:根据索引位置取切片 slice 元素值时，取值范围是（0～len(slice)-1），超界会报运行时错误。生成切片时，结束位置可以填写 len(slice) 但不会报错。)
3.直接申明新切片
每一种类型都可以拥有其切片类型，表示多个类型元素的连续集合。
var name []T //name 表示切片类型的变量名。 //T 表示切片类型对应的元素类型。
package main import "fmt" func main() { // 声明字符串切片 var strList []string // 声明整型切片 strList = []string{"asa","esd"} var numList []int // 声明一个空切片 numListEmpty := []int{1,2,3} // 输出3个切片 fmt.Println(strList, numList, numListEmpty) // 输出3个切片大小 fmt.Println(len(strList), len(numList), len(numListEmpty)) // 切片判定空的结果 fmt.Println(strList == nil) fmt.Println(numList == nil) fmt.Println(numListEmpty == nil) } //运行结果 //[asa esd] [] [1 2 3] //2 0 3 //false //true //false
ps: 1. 切片是动态结构，只能与nil判定相等，不能互相判等。
2. 声明新的切片后，可以使用append() 函数来添加元素。
4.使用 make() 函数构造切片
语法：
make( []T, size, cap )
T：切片的元素类型
size：就是为这个类型分配多少个元素
cap：预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题
package main import "fmt" func main() { a := make([]int, 2) b := make([]int, 2, 10) fmt.Println(a, b) fmt.Println(len(a), len(b)) } //运行结果 //[0 0] [0 0] //2 2
1. a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。
2. 容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。
（ps:使用 make() 函数生成的切片一定发生了内存分配操作。但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。）
5、使用append向切片追加单个元素
1.append() 可以为切片动态添加元素。
2.每个切片会指向一片内存空间，这片空间能容纳一定数量的元素。
3.当空间不能容纳足够多的元素时，切片就会进行“扩容”。
4.“扩容”操作往往发生在 append() 函数调用时。
package main import "fmt" func main() { //声明一个整型切片。 var numbers []int for i := 0; i < 10; i++ { //循环向 numbers 切片添加10个数。 numbers = append(numbers, i) //打印输出切片的长度、容量和指针变化。使用 len() 函数查看切片拥有的元素个数，使用 cap() 函数查看切片的容量情况 fmt.Printf("len: %d cap: %d pointer: %p ", len(numbers), cap(numbers), numbers) } } //运行结果 //len: 1 cap: 1 pointer: 0xc00001c060 //len: 2 cap: 2 pointer: 0xc00001c090 //len: 3 cap: 4 pointer: 0xc000016120 //len: 4 cap: 4 pointer: 0xc000016120 //len: 5 cap: 8 pointer: 0xc00001e180 //len: 6 cap: 8 pointer: 0xc00001e180 //len: 7 cap: 8 pointer: 0xc00001e180 //len: 8 cap: 8 pointer: 0xc00001e180 //len: 9 cap: 16 pointer: 0xc000088000 //len: 10 cap: 16 pointer: 0xc000088000
a.len() 函数并不等于 cap。
b.当元素个数超过cap()的数量时，切片会进行扩容
c.扩容后切片的内存地址发生改变
d.但是切片的名称没有发生改变。
6、使用append向切片中追加多个元素/其他切片
package main import "fmt" func main() { var car []string // 添加1个元素 car = append(car, "OldDriver") // 添加多个元素 car = append(car, "Ice", "Sniper", "Monk") // 添加切片 team := []string{"Pig", "Flyingcake", "Chicken"} car = append(car, team...) fmt.Println(car) } //运行结果 //[OldDriver Ice Sniper Monk Pig Flyingcake Chicken]
在team后面加上了...，表示将 team 整个添加到 car 的后面。