前言
Go中的数组数据类型的长度在声明的时候就已经固定了，切片是基于数组实现的，切片不保存值，底层引用数组的值也就是引用数据类型，但切片是1种可变长度的序列。它支持扩容。
接触了Go中arry、slice，会感觉到Python里面的list数据类型是如此的便捷，感谢Python的作者吧。
Go相对于Python来说是比较偏向底层的语言，为什么只能在arry、slice中只能存相同数据类型的值，是因为Go仅仅选中1块连续的内存地址。
而Python的list可以存不同的数据类型，是因为Python解释器会帮我们通过算法查找散列在 不连续内存上的不同内存地址来获取值。
所以Go执行效率高，但是Python开发效率高。
切片和数组不同的是：
每个切片底层都对应1个数组，为这个切片存值， 所以slice类型变量 在没有初始化前没有分配内存、所以就根本没有默认值 =nil，因为你没有初始化指定长度和元素的数据类型，怎么给你分配这个底层数组呢？
//声明1个数组变量 var a1 [3]int fmt.Println(a1)//声明完了就有默认值 //声明1个切片类型的变量 var s1 []int fmt.Println(s1 == nil)
引子
为什么在Go中有了数组，还需要1个可变长度的切片呢？因为数组需要支持扩容！
package main
import "fmt"
func arraySum(x [3]int) int {
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}
func main() {
a1 := [3]int{1, 2, 3}
//如果函数的参数定义了参数的长度，只能传长度为3的数组，所以数组有一定的局限性
total := arraySum(a1)
fmt.Println(total)
}
//.main.go:14:24: array index 3 out of bounds [0:3]
切片的定义和初始化
切片类型和数组类型一样，想要使用，就必须要定义和初始化，不同之处已经提到，切片不需要指定切片的长度。
1.自定义切片
package main
import (
"fmt"
)
func main() {
//切片的定义
var s1 []int //存放元素不限定，仅限定数据类型
var s2 []string
fmt.Println(s1 == nil) //在初始化之前切片的值=nil
fmt.Println(s2 == nil)
//切片的初始化
s1 = []int{1, 2, 3}
s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
//切片的长度和容量
fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
}
2.由数组得到切片 slice := arry [ : ]
package main
import "fmt"
var a1 [3]string
func main() {
a1 = [3]string{"a", "b", "c"}
// fmt.Printf("%T
", a1)
s1:=a1[:]//数组变成了1个切片,但是使用a1数组存储数据！
// fmt.Printf("%T
", a1)
s1[0]="1"
s1[1]="2"
s1[2]="3"
// s1[3]="4"
// s1[5]="5"
fmt.Println(s1)
}
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
s1 := a1[0:2]
s2 := a1[:4]
s3 := a1[2:]
s4 := a1[:]
fmt.Println(s1, s2, s3, s4)
//切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s1), cap(s1))
fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s2), cap(s2))
fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s3), cap(s3))
}
3.切片的容量
切片s2 := a[3:6]，相应示意图如下：
4.切片为引用类型论证
Go中的切片底层都有1个数组支撑， 切引用这个底层数组的值，所以底层数组改变，切片的值也改变；
// package main
// import (
// "fmt"
// )
// func main() {
// //切片的定义
// var s1 []int //存放元素不限定，仅限定数据类型
// var s2 []string
// fmt.Println(s1 == nil) //在初始化之前切片的值=nil
// fmt.Println(s2 == nil)
// //切片的初始化
// s1 = []int{1, 2, 3}
// s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
// //切片的长度和容量
// fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
// }
// package main
// import (
// "fmt"
// )
// func main() {
// a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
// s1 := a1[0:2]
// s2 := a1[:4]
// s3 := a1[2:]
// s4 := a1[:]
// fmt.Println(s1, s2, s3, s4)
// //切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
// fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s1), cap(s1))
// fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s2), cap(s2))
// fmt.Printf("切片的长度：%d 切片的容量：%d
", len(s3), cap(s3))
// }
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4}
s1 := a1[:3]
fmt.Println(s1)
a1[0] = 666 //修改了a1数组，但是s1引用着a1
s2 := a1[:3]
fmt.Println(s2)
}
5.对切片再切片
package main
import (
"fmt"
)
func main() {
var a1 = [...]int{1, 2, 5, 7, 8, 34}
//对数组进行切片得到切片
s1 := a1[:5]
//对切片再次切片
s2 := s1[3:]
fmt.Println(s1) //[1 2 5 7 8 34]
fmt.Println(s2) //[7 8 34]
fmt.Printf("长度：%d，容量： %d
", len(s1), cap(s1))
fmt.Printf("长度：%d，容量： %d
", len(s2), cap(s2))
}
6.使用make函数构造切片
特点：可以指定切片的长度和容量
package main
import "fmt"
func main() {
//使用make函数创建切片
s1 := make([]string, 10, 20) //string数据类型，指定长度为10，容量为20
fmt.Printf("s1=%v len(s1)=%d cap(s1)=%d
", s1, len(s1), cap(s1))
//s1=[ ] len(s1)=10 cap(s1)=20
s2 := make([]int, 0, 10)
fmt.Printf("s2=%v len(s2)=%d cap(s2)=%d
", s2, len(s2), cap(s2))
//s2=[] len(s2)=0 cap(s2)=10
}
7.如何判断1个空的slice
package main
import "fmt"
func main() {
var s1 []int
fmt.Println(s1 == nil) //true
//切片在赋值阶段才会 创建1个底层数组 来存储该切片的值，所以在没有真正赋值前切片没有对应的底层数组，所以此时的切片值为nil
s1 = []int{}
//如果创建了1个空的切片，它的底层就绑定了1个数组（该数组为空）,所以此时的切片不为nil
fmt.Println(s1 == nil)//false
//那么我们判断1个切片是否为空时应该 判断slice的长度是否为0
fmt.Println(len(s1))
}
8.遍历切片
package main
import "fmt"
func main() {
//遍历切片
Cities := []string{"北京", "上海", "南京"}
for _, v := range Cities {
fmt.Println(v)
}
//变量切片2
for i := 0; i < len(Cities); i++ {
fmt.Println(Cities[i])
}
}
9.append扩容切片
调用append()对原切片进行扩容 必须使变量名 进行接收
package main
import "fmt"
func main() {
//append为切片追加元素
s1 := []string{"北京", "上海", "广州"}
fmt.Printf("扩容前： len(s1):%d,cap(s1):%d
", len(s1), cap(s1))
//s1[4] = "唐山" //因为帮助切片存放值的 arry长度是固定的，这种操作会导致索引越界
//调用append()对原切片进行扩容 必须使原来的s1变量进行接收
s1 = append(s1, "唐县")
fmt.Printf("扩容后：len(s1):%d,cap(s1):%d
", len(s1), cap(s1))
s1 = append(s1, "杭州", "香港")
s2 := []string{"纽约", "洛杉矶"}
s1 = append(s1, s2...)//...代表拆分开s1切片
fmt.Println(s1)
}
切片扩容策略
As I mentioned 每个切片都会指向一个底层数组（固定长度），当切片扩容时它所指向的 定长数组就不能容纳新的元素，所以当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。
//切片的扩容策略
package main
import (
"fmt"
)
var numSlice []int
func main() {
for i := 0; i < 10; i++ {
numSlice = append(numSlice, i)
fmt.Printf("%v len:%d cap:%d ptr:%p
", numSlice, len(numSlice), cap(numSlice), numSlice)
}
}
//输出
/*
[0] len:1 cap:1 ptr:0xc000012098
[0 1] len:2 cap:2 ptr:0xc0000120f0
[0 1 2] len:3 cap:4 ptr:0xc00000a3e0
[0 1 2 3] len:4 cap:4 ptr:0xc00000a3e0
[0 1 2 3 4] len:5 cap:8 ptr:0xc000010200
[0 1 2 3 4 5] len:6 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6] len:7 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6 7] len:8 cap:8 ptr:0xc000010200
[0 1 2 3 4 5 6 7 8] len:9 cap:16 ptr:0xc000068080
[0 1 2 3 4 5 6 7 8 9] len:10 cap:16 ptr:0xc000068080
*/
首先判断，如果新申请容量（cap）大于2倍的旧容量（old.cap），最终容量（newcap）就是新申请的容量（cap）。
否则判断，如果旧切片的长度小于1024，则最终容量(newcap)就是旧容量(old.cap)的两倍，即（newcap=doublecap），
否则判断，如果旧切片长度大于等于1024，则最终容量（newcap）从旧容量（old.cap）开始循环增加原来的1/4，即（newcap=old.cap,for {newcap += newcap/4}）直到最终容量（newcap）大于等于新申请的容量(cap)，即（newcap >= cap）
如果最终容量（cap）计算值溢出，则最终容量（cap）就是新申请容量（cap）。
需要注意的是，切片扩容还会根据切片中元素的类型不同而做不同的处理，比如int和string类型的扩容策略就不一样。
可以通过查看$GOROOT/src/runtime/slice.go源码，其中扩容相关代码如下：
ewcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
newcap = cap
} else {
if old.len < 1024 {
newcap = doublecap
} else {
// Check 0 < newcap to detect overflow
// and prevent an infinite loop.
for 0 < newcap && newcap < cap {
newcap += newcap / 4
}
// Set newcap to the requested cap when
// the newcap calculation overflowed.
if newcap <= 0 {
newcap = cap
}
}
}
slice数据copy（深度拷贝）
既然slice是引用的数据类型，那么我们如何进行深度拷贝？
Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：
package main
import "fmt"
func main() {
s1 := []int{1, 3, 5}
s2 := s1
var s3 = make([]int, 3, 5) //[0 0 0] 注意make创建的切片是有默认值的不是空的
fmt.Println(s1, s2, s3)
//Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：
copy(s3, s1) //参数1:目标序列 参数2：源序列
s1[0]=100
fmt.Println(s1, s2, s3)
/*
s1为[100 3 5]
s2为[100 3 5]
s3为[1 3 5]
s1和s2指向的还是同1个底层数组
copy的操作仅仅是将s1里面的元素，copy到s3里面，但引用了s3引用了1个新的底层数组
*/
}
切片数据删除元素
Go中没有内置的方法，对切片中的元素进行删除操作；
package main
import "fmt"
func main() {
//从切片中删除元素
s1 := []string{"齐国", "楚国", "美国", "日本", "燕国", "韩国", "赵国", "魏国", "秦国"}
//美国和日本不属于战国七雄，怎么把它删除掉？
fmt.Println(s1)
s1 = append(s1[:2], s1[4:]...)
fmt.Println(s1)
}
切片==比较
slice中的数据真正存储在底层数组中，slice是引用数据类型不支持==比较，那我们如何对slice进行相等的比较呢？
需要借助reflect包中的deepEqual方法。
package main
import (
"fmt"
"reflect"
)
func main() {
//在go中数组是支持比较的，因为它是值类型
a1 := [3]int{1, 2, 3}
a2 := [3]int{1, 2, 3}
s1 := []int{1, 2, 3}
s2 := []int{1, 2, 3}
fmt.Println(a1 == a2)
//在go中对2个slice进行比较需要借助refelect
fmt.Println(reflect.DeepEqual(s1, s2))
}
Go切片面试题
面试题1
package main
import "fmt"
func main() {
a1 := [...]int{1, 3, 5} //数组
s1 := a1[:] //切片
fmt.Println(s1, len(s1), cap(s1))
s1 = append(s1[:1], s1[2:]...)
fmt.Println(s1, len(s1), cap(s1))
fmt.Println(a1) //底层数组：[1 5 5]
}
/*
每1个切片都会指向1个底层数组来帮这个切片存储数据（就就像 前端和数据库的关系），切片本身不保存数据值
底层数组就是占用了1块连续的内存
程序员在引用某底层数组的任意1个切片（前端）修改了底层数组（数据库）数据都会发生变化
】
*/
面试题2
package main
import "fmt"
func main() {
s1 := make([]int, 5, 10)
//坑就在make()make创造的切片已经开辟内存了，所以此时s1=[0 0 0 0 0 0 ]
for i := 0; i < 10; i++ {
s1 = append(s1, i)
}
fmt.Println(s1) //[0 0 0 0 0 0 1 2 3 4 5 6 7 8 9]
}