slice
数组的长度在定义之后无法再次修改, 数组是值类型, 每次传递都将产生一个副本。虽然这种数据结构无法满足开发者的真实需求。
Go语言提供了数组切片(slice)来弥补数组的不足。
切片并不是数组或数组指针, 它通过内部指针和相关属性引用数组片段, 以实现变长方案。
slice并不涉及真正意义上的动态数组, 而是一个引用类型。slice总是指向一个底层 array, slice的声明也可以像array一样, 只是不需要长度。
array := [...]int{10, 20, 30, 0, 0}
slice := array[0:3:5]
array [0] 10 [1] 20 [2] 30 [3] 0 [4] 0
slice 地址指针 长度3 容量5 整型切片, 长度为3个整型值, 容量为5个整型值
array：是指向下层数组某元素的指针, 该元素也是切片的起始元素；
len：是切片的长度, 即切片中当前元素的个数；
cap：是切片的最大容量, cap >= len。
[low:high:max]
low: 下标的起点
high: 下标的终点(不包含此下标), [a[low], a[high])左闭右开
max: 最大容量(可选), max值不能大于数组的长度, 也不能小于切片的长度(high - low), 默认值为数组的长度。
len = high - low, 长度
cap = max - low, 容量
提醒: len是切片长度, cap实际上是底层数组的长度, max则可以修改slice的容量
切片和数组的区别
package main //必须有个main包
import(
"fmt"
)
func main(){
//切片和数组的区别
//数组[]里面长度是固定的一个常量, 数组长度不能修改长度, len和cap永远都是5
a := [5]int{}
fmt.Printf("len = %d, cap = %d\n", len(a), cap(a))
//切片, []里面为空, 切片的长度或容量可以不固定
s := []int{}
fmt.Printf("len = %d, cap = %d\n", len(s), cap(s))
s = append(s, 10) //给切片末尾追加一个成员 append函数只能适用于切片
fmt.Printf("append : len = %d, cap = %d\n", len(s), cap(s))
}切片的创建和初始化
slice和数组的区别: 声明数组时, 方括号内写明了数组的长度或使用...自动计算长度, 而声明slice时, 方括号内没有任何字符。
var s1 []int //声明切片和声明array一样, 只是少了长度, 此为空(nil)切片
s2 := []int{} //简短声明方法, 后面的{}括号不能省略
//make([]T, length, capacity) //length参数不能省略, capacity省略, 则和length的值相同
var s3 []int = make([]int, 0) //创建
s3 = []int{1, 2, 3, 4, 5} //初始化
s4 := make([]int, 0, 0) //简短模式切片创建
s4 = []int{1, 2, 3, 4, 5} //初始化
注意: make 只能创建slice、map 和 channel, 并且返回一个有初始值(非零)。
package main
import (
"fmt"
)
func main() { //左括号必须和函数名同行
s1 := make([]int, 16)
s2 := make([]int, 10, 32)
fmt.Println(len(s1), cap(s1)) //16 16
fmt.Println(len(s2), cap(s2)) //10 32
}切片操作
切片截取
s[n] 切片s中索引位置为n的项
s[:] 从切片s的索引位置0到len(s)-1处所获得的切片
s[low:] 从切片s的索引位置low到len(s)-1处所获得的切片
s[:high] 从切片s的索引位置0到high处所获得的切片, len=high
s[low:high] 从切片s的索引位置low到high处所获得的切片, len=high-low
s[low:high:max] 从切片s的索引位置low到high处所获得的切片, len=high-low, cap=max-low
len(s) 切片s的长度, 总是<=cap(s)
cap(s) 切片s的容量, 总是>=len(s)
注意:
low 和 high 是 slice 的索引(index), 其数值必须是整数, max参数用来指定返回的切片的容量
示例说明
array := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
操作 结果 len cap 说明
array[:6:8] [0 1 2 3 4 5] 6 8 省略low
array[5:] [5 6 7 8 9] 5 5 省略high、max
array[:3] [0 1 2] 3 10 省略high、max, 取长度, :3代表从开始位置取三个元素
array[:] [0 1 2 3 4 5 6 7 8 9] 10 10 全部省略
切片与底层数组关系
package main //必须有个main包
import(
"fmt"
)
func main(){
s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
s1 := s[2:5] //[2, 3, 4], 不包括 5, (5-2=3)取三个元素
s1[2] = 100 //修改切片某个元素改变底层数组
fmt.Println(s1, s) //[2 3 100] [0 1 2 3 100 5 6 7 8 9]
s2 := s1[2:6] //新切片依旧指向原底层数组 [100 5 6 7] 注意: 2:6 是 s1 切片的索引, 都是从底层拿到的数据, 对应底层 4:8 的 索引, 虽然 5 6 7 在切片 s2 不存在, 但仍然访问底层的数组
s2[3] = 200
fmt.Println(s2) //[100 5 6 200]
fmt.Println(s) //[0 1 2 3 100 5 6 200 8 9]
}指针直接访问底层数组, 退化成普通数组操作。
package main
import "fmt"
func main() {
s := []int{0, 1, 2, 3}
p := &s[2] // *int, 获取底层数组元素指针。
*p += 100
fmt.Println(s) // [0 1 102 3]
}内建函数
append
append函数向slice尾部添加数据, 返回新的slice对象
package main //必须有个main包
import(
"fmt"
)
func main(){
var s1 []int //创建nil切换
//s1 := make([]int, 0)
s1 = append(s1, 1) //追加1个元素
s1 = append(s1, 2, 3) //追加2个元素
s1 = append(s1, 4, 5, 6) //追加3个元素
fmt.Println(s1) //[1 2 3 4 5 6]
s2 := make([]int, 5) //[0, 0, 0, 0, 0]
s2 = append(s2, 6)
fmt.Println(s2) //[0 0 0 0 0 6]
s3 := []int{1, 2, 3}
s3 = append(s3, 4, 5)
fmt.Println(s3) //[1 2 3 4 5]
}使用 "..."追加
package main
import (
"fmt"
)
func main() {
var a = []int{1, 2, 3}
fmt.Printf("slice a : %v\n", a)
var b = []int{4, 5, 6}
fmt.Printf("slice b : %v\n", b)
c := append(a, b...) //使用 ... 追加
fmt.Printf("slice c : %v\n", c)
d := append(c, 7)
fmt.Printf("slice d : %v\n", d)
e := append(d, 8, 9, 10)
fmt.Printf("slice e : %v\n", e)
}append函数会智能地底层数组的容量增长, 一旦超过原底层数组容量, 通常以2倍容量重新分配底层数组, 并复制原来的数据。
使用make()初始化切片时, length长度最好设置为0, 否则会出现大量无效的值。
注意: append()函数只适合slice切片数据类型的追加。
s := make([]int, 5)
fmt.Println(s) //[0 0 0 0 0]
s = append(s, 6) //[0 0 0 0 0 6]
fmt.Println(s)
package main //必须有个main包
import(
"fmt"
)
func main(){
s := make([]int, 0, 1)
c := cap(s)
for i := 0; i < 50; i++ {
s = append(s, i)
if n := cap(s); n > c {
fmt.Printf("cap : %d -> %d\n", c, n)
c = n
}
}
}输出结果:
cap : 1 -> 2
cap : 2 -> 4
cap : 4 -> 8
cap : 8 -> 16
cap : 16 -> 32
cap : 32 -> 64
copy
函数copy在两个slice间复制数据(也可以复制数组), 两个slice可指向同一底层数组。
func copy(dst, src []Type) int
array -> slice 复制
package main //必须有个main包
import (
"fmt"
"reflect"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} //数组的定义方式
s1 := data[8:] //{8, 9}
s2 := data[:5] //{0, 1, 2, 3, 4}
copy(s2, s1) //dst:s2(目标), src:s1(源)
fmt.Println(s2) //[8 9 2 3 4]
fmt.Println(data) //[8 9 2 3 4 5 6 7 8 9]
fmt.Println(reflect.TypeOf(data), reflect.TypeOf(s2), reflect.TypeOf(s2)) //[10]int []int []int
}array -> slice
package main //必须有个main包
import (
"fmt"
)
func main() {
data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} //数组的定义方式
s1 := data[8:] //{8, 9}
s2 := data[:5] //{0, 1, 2, 3, 4}
copy(s1, s2) //dst:s1(目标), src:s2(源)
fmt.Println(s1) //[0 1]
fmt.Println(data) //[0 1 2 3 4 5 6 7 0 1]
}slice -> slice 复制
package main //必须有个main包
import (
"fmt"
"reflect"
)
func main() {
data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} //数组的定义方式
s1 := data[8:] //{8, 9}
s2 := data[:5] //{0, 1, 2, 3, 4}
copy(s2, s1) //dst:s2(目标), src:s1(源)
fmt.Println(s2) //[8 9 2 3 4]
fmt.Println(data) //[8 9 2 3 4 5 6 7 8 9]
fmt.Println(reflect.TypeOf(data), reflect.TypeOf(s2), reflect.TypeOf(s2)) //[]int []int []int
}汇总
package main //必须有个main包
import (
"fmt"
"reflect"
)
func main() {
/*
同一底层的数组 此种在实际情况少见
*/
data := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} // 切片的定义方式
// 第一种 目标的长度(dst) 大于 源(src) 且操作底层同一数组
s1 := data[8:] //{8, 9}
s2 := data[:5] //{0, 1, 2, 3, 4} 长度为5
copy(s2, s1) //dst:s2(目标), src:s1(源) 本质上是操作底层同一个数组
fmt.Println(s2) //[8 9 2 3 4] 长度与原目标的长度是一致 5, 源(src)全部覆盖目标(dst)
fmt.Println(data) //[8 9 2 3 4 5 6 7 8 9]
fmt.Println(reflect.TypeOf(data), reflect.TypeOf(s2), reflect.TypeOf(s2)) //[]int []int []int
// 第二种 目标的长度(dst) 小于 源(src) 且操作底层同一数组
data2 := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} // 切片的定义方式
s3 := data2[8:] //{8, 9} 长度为 2
s4 := data2[:5] //{0, 1, 2, 3, 4}
copy(s3, s4) //dst:s3(目标), src:s4(源) 本质上是操作底层同一个数组
fmt.Println(s3) // [0 1] 长度与原目标的长度是一致 , 源(src)部分覆盖目标(dst)
/*
不同底层的数组, 在实际的案例比较多见
*/
// 第三种 目标的长度(dst) 小于 源(src) 且操作不同的数组
s5 := []int{8, 9} // 长度为 2
s6 := []int{0, 1, 2, 3, 4} // 定义不同底层的数组
copy(s5, s6) //dst:s3(目标), src:s4(源) 如果 dst(目标) 长度小于 src(源) 的长度, 则 copy 源(src)部分;
fmt.Println(s5) // [0 1] 长度与原目标的长度是一致 2, 源(src)部分覆盖目标(dst)
// 第三种 目标的长度(dst) 大于 源(src) 且操作不同的数组
s7 := []int{8, 9}
s8 := []int{0, 1, 2, 3, 4} // 长度为 5
copy(s8, s7) //dst:s8(目标), src:s7(源) 如果 dst(目标) 长度大于 src(源) 的长度, 则 copy 源(src)全部;
fmt.Println(s8) // [8 9 2 3 4] 长度与原目标的长度是一致 5, 源(src)全部覆盖目标(dst)
}注意: copy("目标", "源"), 它只能用于切片, 不能用于 map 等任何其他类型;
它返回结果为一个 int 型值, 表示 copy 的长度;
源(src)不会发生变化(包括长度len和值), 而目标(dst)的长度len始终不会发生变化, 而目标的值被源(src)的值所覆盖, 具体覆盖多少(部分或全部)取决于目标(dst)的长度(len);
如果 dst(目标) 长度小于 src(源) 的长度, 则 copy 部分;
如果 dst(目标) 长度大于 src(源) 的长度, 则 copy 全部;
切片做函数参数
值传递
package main //必须有个main包
import(
"fmt"
)
func test(s []int){
s[0] = -1
fmt.Println("test : ")
s = append(s, 1000)
for i, v := range s {
fmt.Printf("s[%d] = %d, ", i, v)
}
// s[0] = -1, s[1] = 1, s[2] = 2, s[3] = 3, s[4] = 4, s[5] = 5, s[6] = 6, s[7] = 7, s[8] = 8, s[9] = 9,s[10] = 1000,
fmt.Println("\n")
}
func main(){
slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
test(slice)
fmt.Println("main : ")
for i, v := range slice {
fmt.Printf("slice[%d] = %d, ", i, v)
}
//slice[0] = -1, slice[1] = 1, slice[2] = 2, slice[3] = 3, slice[4] = 4, slice[5] = 5, slice[6] = 6, slice[7] = 7, slice[8] = 8, slice[9] = 9,
}
/*
test :
s[0] = -1, s[1] = 1, s[2] = 2, s[3] = 3, s[4] = 4, s[5] = 5, s[6] = 6, s[7] = 7, s[8] = 8, s[9] = 9, s[10] = 1000,
main :
slice[0] = -1, slice[1] = 1, slice[2] = 2, slice[3] = 3, slice[4] = 4, slice[5] = 5, slice[6] = 6, slice[7] = 7, slice[8] = 8, slice[9] = 9,
*/提示: 我们发现采用值传递, 对切片进行修改操作, 执行的结果一致, 因为实际上切片操作是同一底层数组; 但是采用append()追加元素时, 返回的结果却不一致
引用传递
package main //必须有个main包
import (
"fmt"
)
func test(s *[]int) {
(*s)[0] = -1
*s = append(*s, 1000)
fmt.Println("test : ")
for i, v := range *s {
fmt.Printf("s[%d] = %d, ", i, v)
}
// s[0] = -1, s[1] = 1, s[2] = 2, s[3] = 3, s[4] = 4, s[5] = 5, s[6] = 6, s[7] = 7, s[8] = 8, s[9] = 9, s[10] = 1000,
fmt.Println("\n")
}
func main() {
slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
test(&slice)
fmt.Println("main : ")
for i, v := range slice {
fmt.Printf("slice[%d] = %d, ", i, v)
}
//s[0] = -1, s[1] = 1, s[2] = 2, s[3] = 3, s[4] = 4, s[5] = 5, s[6] = 6, s[7] = 7, s[8] = 8, s[9] = 9, s[10] = 1000,
}
/*
test :
s[0] = -1, s[1] = 1, s[2] = 2, s[3] = 3, s[4] = 4, s[5] = 5, s[6] = 6, s[7] = 7, s[8] = 8, s[9] = 9, s[10] = 1000,
main :
slice[0] = -1, slice[1] = 1, slice[2] = 2, slice[3] = 3, slice[4] = 4, slice[5] = 5, slice[6] = 6, slice[7] = 7, slice[8] = 8, slice[9] = 9, slice[10] = 1000,
*/提示: 我们发现采用引用传递, 对切片进行修改操作, 执行的结果一致, 采用append()追加元素时, 返回的结果一致
注意:
slice 本质上是基于数组实现的, 当传参时, 函数接收到的参数是数组切片的一个复制, 虽然两个是不同的变量, 但是它们都有一个指向同一个地址空间的array指针;
当修改一个数组切片时, 另外一个也会改变, 所以数组切片看起来是引用传递, 其实是值传递;
append()扩容后则使用的不再是同一个内存地址, 因此需要采用引用传递;
结论
(1) append()扩容后则使用的不再是同一个内存地址
(2) 临时变量会开辟新的内存地址, 不会改变原有元素的值
(3) 切片作为函数的参数和返回值时, 一般的情况下没必要使用指针, 除非 append() 扩容的需要;
冒泡法排序切片
package main //必须有个main包
import(
"fmt"
"math/rand"
"time"
)
func InitData(s []int){
//设置种子
rand.Seed(time.Now().UnixNano())
for i := 0; i < len(s); i++ {
s[i] = rand.Intn(100) //100以内的随机数
}
}
func BubbleSort(s []int){
n := len(s)
for i := 0; i < n; i++ {
for j := 0; j < n-1-i; j++ {
if( s[j] > s[j+1]){
s[j], s[j+1] = s[j+1], s[j]
}
}
}
}
func main(){
n := 10
//创建一个切片, len为n
s := make([]int, n)
InitData(s) //初始化数组
fmt.Println("排序前: ", s)
BubbleSort(s) //冒泡排序
fmt.Println("排序后: ", s)
}
/*
排学前: [93 7 8 94 41 36 16 71 63 25]
排学后： [7 8 16 25 36 41 63 71 93 94]
*/删除切片一个元素
Go语言并没有提供用于删除元素的语法或接口, 而是通过利用切片本身的特性来删除元素——追加元素。即以被删除元素为分界点, 将前后两个部分的内存重新连接起来。
使用切片的追加(append)特性, 利用代码实现。
Slice 删除元素的实现
由于切片没有语法糖实现删除, 因此利用其追加元素的特性完成元素的删除操作；通过内建函数 append() 实现对单个元素以及元素片段的删除。
具体的思路就是
确定删除位置 -> 连接起来 -> 原始切片 -> 将删除前后的元素 -> 产生连接后的切片
package main
import (
"fmt"
)
func main() {
// 初始化一个新的切片 seq
seq := []string{"a", "b", "c", "d", "e", "f", "g"}
// 指定删除位置
index := 3
// 输出删除位置之前和之后的元素
//fmt.Println(seq[:index], seq[index+1:])
// seq[index+1:]... 表示将后段的整个添加到前段中
// 将删除前后的元素连接起来
seq = append(seq[:index], seq[index+1:]...)
// 输出链接后的切片
fmt.Println(seq)
}遍历删除切片所遇到的坑
package main
import (
"fmt"
)
func main() {
/*
// 最终报错panic: runtime error: index out of range [3] with length 3, 因为range在迭代时已经确定i的范围为[0,len(arr))的左闭右开的区间。
// 但是当满足arr[i] == 3 时对arr进行了修改, 缩短了arr的长度, 此时len(arr)=3, 最大下标为2, 因此当执行arr[3]时会报错。
// 使用 for...rang
arr := []int{1, 2, 3, 4}
for i := range arr {
if arr[i] == 3 {
arr = append(arr[:i], arr[i+1:]...)
}
}
fmt.Println(arr)
*/
// 正确的写法
arr := []int{1, 2, 3, 4}
for i := 0; i < len(arr); i++ {
fmt.Println(i, arr[i])
if arr[i] == 3 { // 必须采用数组和+下标的方式修改, Go 和 PHP 语法一致
arr = append(arr[:i], arr[i+1:]...) // 删除数组的方式
i--
}
}
fmt.Println(arr)
}注意: 删除切片中的元素时, 要使用 for ... 循环;
尤其是切片的数量发生变化时, 不能使用 for...range 方式, 容易出现数组越界问题
计算切片中最大值
package main
import (
"fmt"
)
func main() {
// 获取最大值
weights := []int{10, 30, 50, 70, 90, 110}
var max int
// var max int = weights[0]
for _, weight := range weights {
if weight > max {
max = weight
}
}
fmt.Println(max) // 110
}总结:
1. 切片：切片是数组的一个引用, 因此切片是引用类型。但自身是结构体, 值拷贝传递。
2. 切片的长度可以改变, 因此, 切片是一个可变的数组。
3. 切片遍历方式和数组一样, 可以用len()求长度。表示可用元素数量, 读写操作不能超过该限制。
4. cap可以求出slice最大扩张容量, 不能超出数组限制。0 <= len(slice) <= len(array), 其中array是slice引用的数组。
5. 切片的定义：var 变量名 []类型, 比如 var str []string var arr []int。
6. 如果 slice == nil, 那么 len、cap 结果都等于 0。
切片函数常见操作
1 将切片 b 的元素追加到切片 a 之后：a = append(a, b...)
2 复制切片 a 的元素到新的切片 b 上：
b = make([]T, len(a))
copy(b, a)
3 删除位于索引 i 的元素：a = append(a[:i], a[i+1:]...)
4 切除切片 a 中从索引 i 至 j 位置的元素：a = append(a[:i], a[j:]...)
5 为切片 a 扩展 j 个元素长度：a = append(a, make([]T, j)...)
6 在索引 i 的位置插入元素 x：a = append(a[:i], append([]T{x}, a[i:]...)...)
7 在索引 i 的位置插入长度为 j 的新切片：a = append(a[:i], append(make([]T, j), a[i:]...)...)
8 在索引 i 的位置插入切片 b 的所有元素：a = append(a[:i], append(b, a[i:]...)...)
9 取出位于切片 a 最末尾的元素 x：x, a = a[len(a)-1], a[:len(a)-1]
10 将元素 x 追加到切片 a：a = append(a, x)
