前言
Go中的数组数据类型的长度在声明之后就无法修改了，切片是基于数组实现的，切片是动态数组，切片是1种可变长度的序列。它支持扩容。
切片不保存值，只保存（len、cap、底层数组的指针），在底层引用数组的值也就是引用数据类型，
接触了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]
切片的定义和初始化
切片类型和数组类型一样，想要使用，就必须要定义和初始化，不同之处已经提到，切片不需要指定切片的长度。
自定义切片
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))
}
由数组得到切片 slice := arry [ : ]
package main
import "fmt"
var a1 [3]string
func main() {
a1 = [3]string{"a", "b", "c"}
// fmt.Printf("%T\n", a1)
s1:=a1[:]//数组变成了1个切片,但是使用a1数组存储数据！
// fmt.Printf("%T\n", 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\n", len(s1), cap(s1))
fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s3), cap(s3))
}
切片的内存管理机制
如果我对切片A再进行切片([区间])或者变量赋值就会拿到1个新的切片B，如果给切片B追加元素那么会影响会怎样呢？
如果我们对切片B进行了appen，那么B的lengh就会不同于A。
如果没有超出容量，切片A、B会同用1个底层数组。
如果超出了原来容量则创建新的底层数组以支撑这个新的切片。
v1 := make([]int, 3, 5) fmt.Println(v1,len(v1),cap(v1)) //v1=[0 0 0] v2 := append(v1, 8) fmt.Println(v2,len(v2),cap(v2)) //v2=[0 0 0 8] fmt.Println(v1,len(v1),cap(v1)) //v2切片的长度经过append之后len=4,切片v1(不同于v2)的长度还是3,他的len决定了v1不会看到8 //[0 0 0] //[0 0 0 8] //[0 0 0]
在Python里面对列表进行切片会开辟1块内存地址存储产生的新列表肯定不会影响。
在golang中如果对切片的切片进行apend操作，append的值会直接覆盖底层数组中值。
Go会.........因为你对1个切片，切几次产生的 “新”切片，只是指针、长度不同，本质都引用了同1个底层数组。
//6.删除元素：go语言没有直接删除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组 fmt.Println(numberList)
切片自动扩容的内存管理机制
1.每1个切片底层都对应了1个数组来保存值，而切片保存这个底层数组的长度（len）、容量（ cap）、底层数组的位置 （point）。
v1:=make([]int,1,3) fmt.Println(len(v1),cap(v1))
2.切片append元素（不产生扩容的情况）
切片追加元素时，在不会产生扩容的情况下，append之后产生的新切片和原切片引用同1个底层数组。
所以对切片进行再次切片时产生的新切片们，本质上就是引用的还是1个底层数组，只不过它们的长度不同，从这块内存上获取数据的起始位置不一样。
v1:=make([]int,1,3) v2:=append(v1,66) //返回新的切片v2 fmt.Println(v1) //[0] fmt.Println(v2) //[0,66] v1[0]=99 fmt.Println(v1) //[99] fmt.Println(v2) //[99 66] fmt.Printf("v1的内存地址：%p,v2的内存地址:%p。",v1,v2)
3.切片在追加（append）元素时，出现了扩容。
一旦出现了扩容就会产生1个新的底层数组来保存原来的数据和新的数据。
所以新、旧切片使用了2个不同的底层数组。它们之间的修改操作不再彼此影响！
v1 :=[]int{11,22,33} //创建1个切片长度为3，容量为3 fmt.Printf("%v 的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1))
--------------------------------------------------------------- v2:=append(v1,44) //apend时产生了扩容，长度为4，容量为6 fmt.Printf("%p\n",v2) v1[0]=101 v2[0]=222 fmt.Printf("%v的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1)) fmt.Printf("%v的长度为：%d,容量为%d.\n",v2,len(v2),cap(v2))
切片为引用类型论证
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\n", len(s1), cap(s1))
// fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
// fmt.Printf("切片的长度：%d 切片的容量：%d\n", 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)
}
切片常见操作
package main import "fmt" func main() { //1.获取切片的长度和容量 var userList = []string{"alex", "eric", "润洪涛"} fmt.Println(len(userList), cap(userList)) //2.s索引获取和修改值 fmt.Println(userList[0]) userList[0] = "李杰" fmt.Println(userList) //3.切片再切片:本质上引用同1个底层数组，但起始位置不一致 v1 := userList[0:2] v2 := userList[1:] v3 := userList[:3] fmt.Println(v1, v2, v3) //4.切片追加元素 v4:=append(userList,"小明","二狗","小刚子") fmt.Printf("%p---%p\n",userList,v4) //5.切片合并 var extendList=[]string{"小何","小黑"} v5:=append(userList,extendList ...) fmt.Printf("%p----%p\n",userList,v5) fmt.Println(v5) //6.切片删除元素：go语言没有直接删除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组 fmt.Println(numberList) //7.切片插入元素 var userList1= []string{"a","b","d","e"} insertIndex:=2 newUserList:=make([]string,0,len(userList1)+1) //长度=0，数组中没数据，就是不初始化值=[] newUserList=append(newUserList,userList1[:insertIndex]...) newUserList=append(newUserList,"c") newUserList=append(newUserList,userList1[insertIndex:]...) fmt.Println(numberList) //错误的想法 result:=append(userList1[:insertIndex],"c") result=append(result,userList1[insertIndex:]...) fmt.Println(result) //8.循环切片 for i:=0;i<len(newUserList);i++{ fmt.Println(newUserList[i]) } //8.for range collection for i, v := range newUserList { fmt.Println(i,v) } }
使用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\n", 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\n", s2, len(s2), cap(s2))
//s2=[] len(s2)=0 cap(s2)=10
}
如何判断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))
}
切片扩容策略
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\n", 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
}
}
}
切片嵌套
package main import "fmt" func main() { v1 := []int{11, 22, 33, 44, 55, 66} fmt.Println(v1) //切片套切片 v2 := [][]int{[]int{1, 2}, []int{3, 4}} fmt.Println(v2) //切片套数组 v3 := [][2]int{[2]int{1, 2}, [2]int{3, 4}} fmt.Println(v3) }
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语言内置的sort包对切片进行排序。
在查找切片某1元素的index位置时，需要提前对切片进行排序这一点和Python/JS有很大不同。
JavaScript
arry1=[3,19,88]
console.log(arry1.indexOf(88))
Python
l1=[1,12,2] print(l1.index(2))
Golang
在Golang中我们需要自己进行循环遍历然后seek到某个在slice中的index位置，
或者借助sort包中的search功能，但是该功能的实现为二分法查找法，所以我们需要对since提前进行排序。
package main
import (
"fmt"
"sort"
)
func main() {
//切片排序
numberList := []int{
1993, 1955, 1988, 1990, 1958,
}
sort.Ints(numberList)
fmt.Println(numberList)
//切片倒序
sort.Sort(sort.Reverse(sort.IntSlice(numberList)))
fmt.Println(numberList)
//字符串排序
nameList := []string{"aa", "bbx", "xx"}
sort.Strings(nameList)
fmt.Println(nameList)
//在切片中查询元素
fmt.Println(numberList)
books := []string{"Hello", "World", "Ni", "Hao", "Mei", "Nv"}
//必须先排序之后才能获取索引，因为SearchStrings使用二分法查找，有序是前提。
sort.Strings(books)
fmt.Println("现在你看到的是排序后的books", books)
fmt.Println(sort.SearchStrings(books, "Ni"))
}
Go切片面试题
练习
package main import "fmt" func main() { /* 1.简述切片和数组的区别？ 区别1.切片变量赋值之后产生的新，在新切片在不扩容的前提下，如果修改了元素，底层数组和共同引用这一数组的切片会受影响 区别2.数组变量赋值之后产生的新数组，不会和原数组使用1块内存。 区别3：切片支持自动扩容，数组不可以。 2.简述new和make的区别？ new返回的是一个对象的指针类型，make返回的是一个对象 make初始比new多了2个参数，make可以帮助我们设置数据类型的默认长度、默认容量 3.看代码写结果 v1:=make([]int,2,5) fmt.Println(v1[0],len(v1),cap(v1)) 结果---0 2 5 4.看代码写结果 v1 := make([]int, 2, 5) v2 := append(v1, 123) //[0 0 123] fmt.Println(v2) //2 5 fmt.Println(len(v1), cap(v1)) //3 5 fmt.Println(len(v2), cap(v2) 5.看代码写结果:切片扩容了 v1 := make([]int, 2, 2) v2 := append(v1, 123) v1[0]=99 fmt.Println(v1) fmt.Println(v2) 6.看代码写结果：切片没有扩容 var v1=make([]int,2,2) v2:=v1[0:2] v1[0]=11 fmt.Println(v1) fmt.Println(v2) //[11 0] //[11 0] 7.看代码猜结果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v1[0][2]=333 fmt.Println(v1) //[[11 22 333 44] [44 55]] 8.看代码写结果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v2:=v1[0] v2[1]=222 fmt.Println(v1) fmt.Println(v2) [[11 222 33 44] [44 55]] [11 222 33 44] 10.看代码写结果 v1:=[][]int{[]int{11,22,33,44},[]int{44,55}} v2:=append(v1[0],99) //扩容了产生了新的底层数组 [11 22 33 44 99] v2[2]=444 fmt.Println(v1) //[[11 22 33 44] [444 55]] 11.看代码写结果 v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]] v2 := append(v1[0], 99) //v2=[0 0 99]没有扩容 v2[0] = 66 //v2=[66 0 99] fmt.Println(v2) fmt.Println(v1) //由于v1的len没有改变，所以它看到的是 [[66 0] [0 0]] */ v1 := [][]int{make([]int, 2, 5), make([]int, 2, 3)} //[[0 0] [0 0]] v2 := append(v1[0], 99) //v2=[0 0 99]没有扩容 v2[0] = 66 //v2=[66 0 99] fmt.Println(v2) fmt.Println(v1) //由于v1的len没有改变，所以它看到的是 [[66 0] [0 0]] }
基于slice实现队列和栈
package main
import "fmt"
func main() {
//基于切片实现一个队列
queue := []string{}
queue = append(queue, "a", "b", "c")
fmt.Println(queue[0])
queue = queue[1:]
fmt.Println(queue[0])
queue = queue[1:]
fmt.Println(queue[0])
//基于切片实现一个栈
stack := []string{}
stack = append(stack, "a", "b", "c")
fmt.Println(stack[len(stack)-1])
stack = stack[:len(stack)-1]
fmt.Println(stack[len(stack)-1])
stack = stack[:len(stack)-1]
fmt.Println(stack[len(stack)-1])
}
面试题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]
}
初始化1个6行7列的数组
var bigArry [6][]int func main() { for i := 0;i<6;i++ { bigArry[i] = make([]int,7) } fmt.Println(bigArry) bigArry=[6][]int{ []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, []int{0,0,0,0,0,0,0}, } fmt.Println(bigArry) }