demo1:切片定义的几种方式
package main
import "fmt"
/*
切片定义的几种方式
数组和切片区别:
使用数组传参是值传递,而使用切片传参是引用传递
数组定义好长度之后不可修改,而切片可以理解为动态数组,长度可修改
*/
func main() {
//方法1:直接创建
s1 := []string{"1", "2", "3"}
fmt.Printf("%T\n", s1)
fmt.Println(len(s1))
fmt.Println(s1)
fmt.Println("--------------------------------------")
//方法2:使用make定义,但是需要加上长度,cap可加可不加
s2 := make([]string, 3) //s2:=make([]string, 3,5) 加cap写法
fmt.Printf("%T\n", s2)
fmt.Println(len(s2))
fmt.Println(s2)
fmt.Println("--------------------------------------")
//方法3:数组变切片
arr := [3]string{"1", "2", "3"}
s3 := arr[1:2]
fmt.Printf("%T\n", s3)
fmt.Printf("%T\n", arr)
fmt.Println(len(s3))
fmt.Println(s3)
fmt.Println("--------------------------------------")
//方法4:new
s4 := new([]string)
fmt.Printf("%T\n", s4)
//fmt.Println(len(s4)) //没有长度
fmt.Println(s4) //&[]
}
demo2: 切片的基本操作
package main
import "fmt"
/*
切片的基本操作:添加、复制、合并、删除
*/
func main() {
s1 := []string{"1", "2", "3"}
//添加
s1 = append(s1, "4", "5")
fmt.Println(s1)
//复制
s2 := []string{}
copy(s2, s1)
fmt.Println(s2) //这里s2为空,因为没定义长度
//拷贝时,目标对象长度为多少就只能复制多少
s3 := make([]string, len(s1))
copy(s3, s1)
fmt.Println(s3)
//把两个切片合并
s2 = append(s1, s3...) //省略号是规定的参数
fmt.Println(s2)
//数组中删除元素:先把数组变成切片,再把两个切片合并
s4 := s2[:]
s4 = append(s2[0:2], s2[4:]...)
fmt.Println(s4)
}
demo3: 切片的cap和len
package main
import "fmt"
/*
切片的容量(cap)和长度(len)
slice的底层是使用数组实现的,同一个数组的切片会共享内存,但如果切片扩容超过切片的原有容量cap会触发扩容机制,该切片就会自己独立开辟全新内存空间。
slice的append扩容问题:扩容阶段因为需要整体开辟全新的内存空间,因此扩容阶段会影响速度。python的list中底层实际上也是数组,也会面临扩容影响速度的问题。
python的同一list中可以存不同的数据类型。
*/
func main() {
//不设置cap时,len和cap大小一致
s1 := []string{"1", "2", "3"}
fmt.Println(len(s1)) //3
fmt.Println(cap(s1)) //3
s2 := make([]int, 5)
fmt.Println(len(s2)) //3
fmt.Println(cap(s2)) //3
s3 := make([]int, 5, 8) //设置了容量cap
fmt.Println(len(s3)) //5
fmt.Println(cap(s3)) //8
//通过数组取切片:cap为切片起始位置之后的数组长度
s4 := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s5 := s4[2:5]
fmt.Println(len(s5)) //3
fmt.Println(cap(s5)) //8
//append函数遇到make问题:如果用make创建切片时定义了长度,append操作会在原有元素之后进行插入。如果没有定义长度,append操作则是对默认元素0进行替换
s6 := make([]int, 3)
s6 = append(s6, 1)
fmt.Println(s6) //[0 0 0 1]
s7 := make([]int, 0)
s7 = append(s7, 1)
fmt.Println(s7) // [1]
}
demo4:切片扩容
案例1:
package main
import (
"fmt"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
s := data[:2:3]
fmt.Println(s)
fmt.Println(len(s), cap(s))
s = append(s, 100, 200, 300) // 一次 append 三个值,超出 s.cap 限制。
fmt.Println(s, data) // 重新分配底层数组,与原数组无关。
fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。
}
从输出结果可以看出:append 后的 s 被重新分配了底层数组(也就是说 s 的底层数组不再是 data,那么修改 s 的值不会再影响 data,它们不再有关联),并把原数组中的值拷贝到新数组中。这是因为超出了原切片的容量。在上例中,如果只追加一个值,则不会超过 s.cap 限制,也就不会重新分配。
切片的自动扩容策略是这样的:(文章:简单说说go语言Slice的底层实现_Liuzhiwang29的博客-CSDN博客 简单说说go语言Slice的底层实现 通过分析源码对这一点提出了质疑)通常 以 2 倍容量 进行扩容,并重新分配底层数组(新底层数组的容量也变大)。如果切片的容量小于 1024 个元素,扩容的时候就翻倍增加容量。一旦元素个数超过 1024 个元素,那么增长因子就变成 1.25 ,即每次增加原来容量的四分之一。注意:扩容扩大的容量都是针对原来的容量而言的,而不是针对原来数组的长度而言的。
所以,在大批量添加数据时,建议 一次性分配足够大的空间 ,以减少内存分配和数据复制开销。或 初始化足够长的 len 属性,改用索引号进行操作。及时释放不再使用的 slice 对象,避免持有过期数组,造成 GC 无法回收。
slice中 cap 重新分配规律:
package main
import (
"fmt"
)
func main() {
s := make([]int, 0, 1)
fmt.Println(s)
c := cap(s) //计算容量
fmt.Println(c)
for i := 0; i < 50; i++ {
s = append(s, i) //按理说 append 第2个元素时就超出了cap,这时会重新分配底层数组来扩大cap
if n := cap(s); n > c {
fmt.Printf("cap: %d -> %d\n", c, n)
c = n
}
}
}
输出结果:
[]
1
cap: 1 -> 2
cap: 2 -> 4
cap: 4 -> 8
cap: 8 -> 16
cap: 16 -> 32
cap: 32 -> 64
我们可以发现,通常以 2 倍的 cap 重新分配。
提一嘴哈,如果给切片 append 元素时,不超切片容量就没事,操作的还是原数组:
package main
import (
"fmt"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 10: 0} //数组
s := data[:2:5] //将切片容量扩大到5
fmt.Println(s)
fmt.Println(len(s), cap(s))
s = append(s, 100, 200, 300) // 一次 append 三个值,这次没超出 s.cap 限制。
fmt.Println(s, data)
fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针
}
输出结果:
[0 1]
2 5
[0 1 100 200 300] [0 1 100 200 300 0 0 0 0 0 0]
0xc00004a060 0xc00004a060
案例2:
package main
import "fmt"
//slice的扩容
func main() {
arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
s1 := arr[2:6]
s2 := s1[3:5]
fmt.Printf("s1=%v,len(s1)=%d,cap(s1)=%d\n", s1, len(s1), cap(s1)) //2,3,4,5
fmt.Printf("s2=%v,len(s2)=%d,cap(s2)=%d\n", s2, len(s2), cap(s2)) //5,6,为什么s2中取到6,是因为slice支持向后扩容
//slice的操作:向slice中添加元素
s3 := append(s2, 10)
s4 := append(s3, 11)
s5 := append(s4, 12)
fmt.Println("s3,s4,s5:", s3, s4, s5)
fmt.Println("arr:", arr) //为什么没有11,12? 是因为不能超过cap,如果超过cap则会重新分配一个数组进行存储
}