前言
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] }