数组
Go语言中的数组是定长的同一类型数据的集合，数组索引是从0开始的。
数组有以下几种创建方式
// 声明一个叫 balance的 10个元素的float32 数组
var balance [10] float32
//数组初始化
var balance = [5]float32{1000.0, 2000.0, 3000.4, 7000.0, 5000.0}
// 忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数自动设置数组的大小
var balance = [...]float32{1000.0, 2000.0, 3000.4, 7000.0, 5000.0}
以下是一些特殊数组
[2*N] struct {x,y int32} //复杂类型数组
[1000]* float64 //指针数组
[3][5]int //二维数组
[2][3][5]float64 // 等同于 [2]([3][5]float64)
当创建数组时，若没有被显示的初始化或者只是部分初始化，那么Go语言会自动的把数组其他的项都初始化为0（元素类型默认值）
获取数组长度，使用len函数；获取数组容量大小，使用cap函数，由于数组长度不可变，因此数组的容量等于长度。
len(arr) == cap(arr)
访问数组
使用 len 遍历
for i := 0; i < len(arr); i++ {
fmt.Printf("%c", arr[i])
}
使用 range 遍历，有两个返回值，第一个是 元素的数组下标，第二个是元素的值
for _, v := range arr{
fmt.Printf("%c", v)
}
数组是值传递，因此在函数内操作数组只是数组的一个副本，不会影响数组本身，但可以通过传递指针来避免值传递。
func main() {
array := [5]int{1,2,3,4,5}
modify(array)
fmt.Println("In main, array values:",array)
}
func modify(array [5]int) {
array[0] = 10
fmt.Println("In modify, array values:",array)
}
------------output-----------
In modify, array values: [10 2 3 4 5]
In main, array values: [1 2 3 4 5]
数组切片
是引用类型，可以自动扩容但容量固定，弥补数组的长度在定义后无法再次修改，在函数体内无法对外部的数组内部结构进行修改的缺点。
数组切片的数据结构可以抽象为以下3个变量：
①一个指向原生数组的指针
②数组切片中的元素个数
③数组切片已分配的存储空间
数组与切片都可以使用下面所给出的语法进行切片
s[n] //切片s中索引为n的项
s[n:m] //从切片s的索引位置 n 到 m-1 处所获得的切片
s[n:] //从切片s的索引位置 n 到len(s)-1处所获得的切片
s[:m] //从切片s的索引位置 0 到 m-1 处所获得的切片
s[:] //切片s的索引位置0到len(s)-1处所获得的切片
cap(s) //获得切片的容量：总是>= len(s)
len(s) //获得切片包含元素的个数：总是<= cap(s)
s[:cap(s)] //增加切片s的长度到其容量，如果长度小于等于容量的话
注：s == s[:n]+s[n:] //s是一个字符串，n为整型，0<=n<=len(s)
创建数组切片有以下几种方式
①基于数组创建数组切片
var myArray [10]int = [10]int{1,2,3,4,5}
var mySlice []int = myArray[:5] //前五个元素创建数组切片
var mySlice []int = myArray[:] // 所有元素创建数组切片
②直接创建数组切片
//创建元素初始值为0，比如下面初始元素个数即长度为5（必须设定）
//预留10个元素的存储容量（可以不设定，默认跟初始元素相等），空间容量大于等于初始元素个数
mySlice :=make([]int,5,10)
mySlice := []int{1,2,3,4,5}
③基于数组切片创建数组切片（指向同一个隐藏数组）
func main() {
mySlice1 := []int{1,2,3,4,5} //容量与长度相同
mySlice2 := mySlice1[:3]
fmt.Println(mySlice2)
}
只要mySlice2选择的范围 mySlice1[:n] 这个n不超过 cap(mySlice1) 的值即可，自动补充0
当创建一个切片时，它会创建一个隐藏的初始化为零值的数组，然后返回引用该隐藏数组的切片。该隐藏数组也是固定长度的，该长度始终等于切片的容量。比如下图所示的切片x，基于切片x创建的切片y，隐藏数组。
由于数组切片是一个引用类型，因此若有多个指向同一个隐藏数组的切片中的某一个进行修改操作，那么其他切片都会受影响
func main() {
var mySlice1 = []int{1,2,3,4,5,6,7}
mySlice2 := mySlice1[:5]
mySlice3 := mySlice1[3:]
fmt.Println(mySlice1,mySlice2,mySlice3)
mySlice3[0] = 100
fmt.Println(mySlice1,mySlice2,mySlice3)
}
-----output-----
[1 2 3 4 5 6 7] [1 2 3 4 5] [4 5 6 7]
[1 2 3 100 5 6 7] [1 2 3 100 5] [100 5 6 7]
空数组切片
一个数组切片未被初始化时，默认为nil，存储空间长度为0，元素个数为0
len(): 返回当前切片存储的元素个数 cap(): 返回数组切片分配的存储空间
var numbers []int // len=0 cap=0 slice=[]
动态增减元素，合理的设置数组切片的存储空间，将会减少切片内部重新分配内存和搬送内存块的频率，提高性能。
接下来我们看一个创建切片综合运用实例
func main() {
/* 创建切片 */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers) // len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
/* 打印原始切片 */
fmt.Println("numbers ==", numbers) //numbers == [0 1 2 3 4 5 6 7 8]
/* 打印子切片从索引1(包含) 到索引4(不包含)*/
fmt.Println("numbers[1:4] ==", numbers[1:4]) //numbers[1:4] == [1 2 3]
/* 默认下限为 0*/
fmt.Println("numbers[:3] ==", numbers[:3]) //numbers[:3] == [0 1 2]
/* 默认上限为 len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:]) //numbers[4:] == [4 5 6 7 8]
numbers1 := make([]int,0,5)
printSlice(numbers1) //len=0 cap=5 slice=[]
/* 打印子切片从索引 0(包含) 到索引 2(不包含) */
number2 := numbers[:2]
printSlice(number2) // len=2 cap=9 slice=[0 1]
/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
number3 := numbers[2:5]
printSlice(number3) //len=3 cap=7 slice=[2 3 4]
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
总结：基于一个数组切片a通过s[n:m]方式创建一个新的子切片b，那么子切片b的容量等于a切片容量减去n
向数组切片添加元素
切片不支持+=操作，所以要继续增加存储的元素，可以使用append 函数。append 函数可以直接将一个数组切片加到当前数组切片的后面，记住添加的数组切片后边必须加三个点，相当于把mySlice1的所有元素打散后传入mySlice，但是传入的mySlice1所有元素顺序不变，使用append函数的两个数组切片的元素类型必须是相同的。若原始切片的容量不足够容纳原始元素和新添加进来的元素，那么append 函数将会隐式的创建一个新的切片，并将原始元素与新元素都添加进来。
//numbers指切片，n指元素，这个n可以为空，那么依旧为原数组切片
numbers = append(numbers, n)
//示例一
func main() {
var mySlice1 = make([]int,5,10)
fmt.Printf("mySlice1:%v, len(mySlice1):%v, cap(mySlice1):%v\n",mySlice1,len(mySlice1),cap(mySlice1))
mySlice1 = append(mySlice1,1,2,3)
fmt.Printf("mySlice1:%v, len(mySlice1):%v, cap(mySlice1):%v\n",mySlice1,len(mySlice1),cap(mySlice1))
mySlice2 := []int{4,5,6}
mySlice1 = append(mySlice1,mySlice2...)
fmt.Printf("mySlice1:%v, len(mySlice1):%v, cap(mySlice1):%v\n",mySlice1,len(mySlice1),cap(mySlice1))
}
------output------
mySlice1:[0 0 0 0 0], len(mySlice1):5, cap(mySlice1):10
mySlice1:[0 0 0 0 0 1 2 3], len(mySlice1):8, cap(mySlice1):10
mySlice1:[0 0 0 0 0 1 2 3 4 5 6], len(mySlice1):11, cap(mySlice1):20
之前说切片的底层实现是通过共享数组的方式实现的，append在进行添加元素时，会首先检查原切片的可用容量，也就是底层共享数组的长度是否满足，如果底层数组长度不够，那么就会分配一个新的数组，将被引用的所有的值复制到新数组当中，再继续添加新元素。
如果是新切片进行append添加新元素，那么原切片的容量与长度都不会改变，哪怕新切片扩容超过原切片的容量
//示例二
func main() {
a := []int{1, 2, 3, 4, 5}
b := a[2:3]
fmt.Println("a: ", a, " len: ", len(a), " cap: ", cap(a))
fmt.Println("b: ", b, " len: ", len(b), " cap: ", cap(b))
b = append(b, 6)
fmt.Println("a: ", a, " len: ", len(a), " cap: ", cap(a))
fmt.Println("b: ", b, " len: ", len(b), " cap: ", cap(b))
}
---output---
a: [1 2 3 4 5] len: 5 cap: 5
b: [3] len: 1 cap: 3
a: [1 2 3 6 5] len: 5 cap: 5
b: [3 6] len: 2 cap: 3
在上面的示例中使用newSlice = Slice[n:m]，新切片的容量会随着旧切片走。如果使用索引参数就可以来指定新切片的容量
//示例三
a := []int{1, 2, 3, 4, 5}
c := a[2:3:4] //注：a[i:j:k]：容量cap = k-i，长度len = j-i，因为a的容量为5，因此这里k的值最大不能大于5，k< cap(a)
fmt.Println("c: ", c, " len: ", len(c), " cap: ", cap(c))
----output----
c: [3] len: 1 cap: 2
若将k的值大于cap(a)，也就是设定新切片容量大于旧切片容量时，那么就会报运行时错误，这个很难找到错误原因。
c := a[2:3:6]
---------------------------------------------------------
panic: runtime error: slice bounds out of range
goroutine 1 [running]:
main.main()
D:/GoDemo/src/MyGo/Demo_05.go:17 +0x74a
解决方法：如果在创建新切片时，设定长度与容量一致，新切片进行append操作时，会强制在底层立即创建新的数组，这就跟原切片在底层上不是共享同一数组，这样就可以安全的操作新切片，将上面的示例二中 b := a[2:3] 改为 b := a[2:3:3] 进行结果对比
//设置新切片长度与容量都相等的情况
a := []int{1, 2, 3, 4, 5}
b := a[2:3:3] //只取出原切片索引为2的值，并设定新切片容量与长度都为1
fmt.Println("a: ", a, " len: ", len(a), " cap: ", cap(a))
fmt.Println("b: ", b, " len: ", len(b), " cap: ", cap(b))
//新切片添加新元素操作
b = append(b,6 )
fmt.Println("a: ", a, " len: ", len(a), " cap: ", cap(a))
fmt.Println("b: ", b, " len: ", len(b), " cap: ", cap(b))
---output---
a: [1 2 3 4 5] len: 5 cap: 5
b: [3] len: 1 cap: 1
a: [1 2 3 4 5] len: 5 cap: 5
b: [3 6] len: 2 cap: 2
内容复制
使用Go语言另一个内置函数copy函数，它接受两个包含相同类型元素的切片，并将源切片的元素复制到目标切片，同时返回所复制元素的数量。若这两个切片不是一样大，那么自动按照较小的数组切片的元素个数进行复制。这个复制只是复制数值，原切片索引值改变，不会影响到新的切片
func main() {
mySlice1 := []int{1,2,3,4,5}
mySlice2 := []int{6,7,8}
copy(mySlice1,mySlice2) //将mySlice2 复制到 mySlice1 的前3个位置
fmt.Println(mySlice1) // [6 7 8 4 5]
copy(mySlice2,mySlice1) //因为mySlice2的长度比mySlice1小，反过来就是将 mySlice1 的前3个元素复制到mySlice2
fmt.Println(mySlice2) // [1 2 3]
mySlice1[0] = 100
fmt.Println(mySlice1) //[100 2 3 4 5]
fmt.Println(mySlice2) //[1 2 3]
}
切片迭代
同样可以使用range配合for循环迭代输出切片中的元素，但是要注意这里的range迭代输出的两个值：第一个值是当前迭代的索引位置，第二个值是该位置对应元素值的副本。
func main() {
slice := []int{10, 20, 30, 40}
// 迭代每一个元素，并显示其值
for index, value := range slice {
fmt.Printf("Index: %d Value: %d\n", index, value)
}
}
---output---
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40
range迭代切片时，会返回当前迭代的索引位置与该位置对应元素值的副本，range为每个元素都创建了副本，而不是直接返回对该元素的引用。
如果使用返回value值的地址作为指向每个元素的指针，就会造成错误，因为每个value值的地址都是相同的，无法区分.
func main() {
slice := []int{10, 20, 30, 40}
// 迭代每一个元素，并显示其值
for index, value := range slice {
fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n",
value, &value, &slice[index])
}
}
----output----
Value: 10 Value-Addr: C042060080 ElemAddr: C04205E0C0
Value: 20 Value-Addr: C042060080 ElemAddr: C04205E0C8
Value: 30 Value-Addr: C042060080 ElemAddr: C04205E0D0
Value: 40 Value-Addr: C042060080 ElemAddr: C04205E0D8
结论：每次迭代返回的变量value值其实是在迭代过程中据切片依次赋值的新变量，不是切片中原来的值了，因此如果需要求得每个元素的地址，还是使用 &slice[index] 的方式
切片操作实战
①插入元素。先保存后面的元素，再取前面的元素添加元素，再组合起来
第一种：利用append函数
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
index := 5
insertSlice := []int{1000}
name1 := append([]int{},name[index:]...) //name1: [6 7 8 9 10]
name2 := append(name[:index],insertSlice...) //name2: [1 2 3 4 5 1000]
name2 = append(name2,name1...)
fmt.Println(name2) //name2: [1 2 3 4 5 1000 6 7 8 9 10]
}
上面的方法可以再简化如下
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
index := 5
insertSlice := []int{1000}
name = append(name[:index],append(insertSlice, name[index:]...)...)
fmt.Println(name) //name2: [1 2 3 4 5 1000 6 7 8 9 10]
}
第二种：利用copy函数
func main() {
var slice = []int{1,2,3,4,5,6,7,8,9,10}
insertSlice := []int{1000}
index := 5 //插入的切片索引
//根据原始切片与新切片创建新的切片
result := make([]int,len(slice)+len(insertSlice))
at := copy(result,slice[:index])
at += copy(result[at:],insertSlice)
copy(result[at:],slice[index:])
fmt.Println(result) // result：[1 2 3 4 5 1000 6 7 8 9 10]
}
②删除元素。
从开头删除某个索引处的元素
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
name = name[1:]
}
从结尾删除某个索引处的元素
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
name = name[:9]
}
从中间删除某个索引处的元素
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
a := len(name)/2
name = append(name[:a],name[a+1:]...) //name: [1 2 3 4 5 7 8 9 10]
}
删除某一个索引区间的全部元素
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}//name: [1 2 3 4 5 6 7 8 9 10]
start := 1
end := 5
name = append(name[:start],name[end:]...) //name: [1 6 7 8 9 10]
}
使用copy同样能达到目的
③切片尾部追加元素
func main() {
var name = []int{1,2,3,4,5,6,7,8,9,10}
fmt.Println("name: ",name)
//尾部追加元素
for i:=11;i<=15 ;i++ {
name = append(name,i)
}
fmt.Println("name: ",name)
}
append函数修改切片会改变原始切片，而copy函数修改不会。
关于切片的指针
①当我们用append追加元素到切片时，如果容量不够，go就会创建一个新的切片变量，看下面程序的执行结果：
func main() {
var sa []int
fmt.Printf("addr:%p \tlen:%v \tcontent:%v\n",sa,len(sa),sa);
for i:=0;i<10;i++{
sa=append(sa,i)
fmt.Printf("addr:%p \tlen:%v \t content:%v\n",sa,len(sa),sa);
}
fmt.Printf("addr:%p \tlen:%v \t content:%v\n",sa,len(sa),sa);
}
------output-------
addr:0x0 len:0 content:[]
addr:0xc042060088 len:1 content:[0]
addr:0xc0420600c0 len:2 content:[0 1]
addr:0xc04205e0e0 len:3 content:[0 1 2]
addr:0xc04205e0e0 len:4 content:[0 1 2 3]
addr:0xc042084100 len:5 content:[0 1 2 3 4]
addr:0xc042084100 len:6 content:[0 1 2 3 4 5]
addr:0xc042084100 len:7 content:[0 1 2 3 4 5 6]
addr:0xc042084100 len:8 content:[0 1 2 3 4 5 6 7]
addr:0xc04208e000 len:9 content:[0 1 2 3 4 5 6 7 8]
addr:0xc04208e000 len:10 content:[0 1 2 3 4 5 6 7 8 9]
addr:0xc04208e000 len:10 content:[0 1 2 3 4 5 6 7 8 9]
因为初始时指定的切片容量不足，因此切片在进行append操作时，会自动扩容产生新的切片变量，因此切片变量地址会频繁变动
因此在不能预估切片的容量情况下，又要防止切片变量地址频繁变动，我们就需要使用指针来操作切片变量，其本质上是：append操作亦然会在需要的时候构造新的切片，不过是将地址都保存到了sa中，因此我们通过该指针始终可以访问到真正的数据。
func main() {
var osa = make ([]int,0);
sa:=&osa;
for i:=0;i<10;i++{
*sa=append(*sa,i)
fmt.Printf("addr of osa:%p,\taddr:%p \t content:%v\n",osa,sa,sa);
}
fmt.Printf("addr of osa:%p,\taddr:%p \t content:%v\n",osa,sa,sa);
}
-------output--------
addr of osa:0xc042060080, addr:0xc04205a3e0 content:&[0]
addr of osa:0xc0420600b0, addr:0xc04205a3e0 content:&[0 1]
addr of osa:0xc04205e0e0, addr:0xc04205a3e0 content:&[0 1 2]
addr of osa:0xc04205e0e0, addr:0xc04205a3e0 content:&[0 1 2 3]
addr of osa:0xc042084100, addr:0xc04205a3e0 content:&[0 1 2 3 4]
addr of osa:0xc042084100, addr:0xc04205a3e0 content:&[0 1 2 3 4 5]
addr of osa:0xc042084100, addr:0xc04205a3e0 content:&[0 1 2 3 4 5 6]
addr of osa:0xc042084100, addr:0xc04205a3e0 content:&[0 1 2 3 4 5 6 7]
addr of osa:0xc04208e080, addr:0xc04205a3e0 content:&[0 1 2 3 4 5 6 7 8]
addr of osa:0xc04208e080, addr:0xc04205a3e0 content:&[0 1 2 3 4 5 6 7 8 9]
addr of osa:0xc04208e080, addr:0xc04205a3e0 content:&[0 1 2 3 4 5 6 7 8 9]
