1、切片(Slice)
1.1 什么是切片
Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大
切片是一种方便、灵活且强大的包装器。切片本身没有任何数据。它们只是对现有数组的引用。
切片与数组相比，不需要设定长度，在[]中不用设定值，相对来说比较自由
从概念上面来说slice像一个结构体，这个结构体包含了三个元素：
- 指针，指向数组中slice指定的开始位置
- 长度，即slice的长度
- 最大长度，也就是slice开始位置到数组的最后位置的长度
1.2 切片的语法
定义切片
var identifier []type
切片不需要说明长度。
或使用make()函数来创建切片:
var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)
make([]T, length, capacity)
初始化
s[0] = 1
s[1] = 2
s[2] = 3
s :=[] int {1,2,3 }
s := arr[startIndex:endIndex]
将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片（前闭后开），长度为endIndex-startIndex
s := arr[startIndex:]
缺省endIndex时将表示一直到arr的最后一个元素
s := arr[:endIndex]
缺省startIndex时将表示从arr的第一个元素开始
package main
import (
"fmt"
)
func main() {
a := [5]int{76, 77, 78, 79, 80}
var b []int = a[1:4] //creates a slice from a[1] to a[3]
fmt.Println(b)
}
1.3 修改切片
slice没有自己的任何数据。它只是底层数组的一个表示。对slice所做的任何修改都将反映在底层数组中。
示例代码：
package main
import (
"fmt"
)
func main() {
darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
dslice := darr[2:5]
fmt.Println("array before",darr)
for i := range dslice {
dslice[i]++
}
fmt.Println("array after",darr)
}
运行结果：
array before [57 89 90 82 100 78 67 69 59]
array after [57 89 91 83 101 78 67 69 59]
当多个片共享相同的底层数组时，每个元素所做的更改将在数组中反映出来。
示例代码：
package main
import (
"fmt"
)
func main() {
numa := [3]int{78, 79 ,80}
nums1 := numa[:] //creates a slice which contains all elements of the array
nums2 := numa[:]
fmt.Println("array before change 1",numa)
nums1[0] = 100
fmt.Println("array after modification to slice nums1", numa)
nums2[1] = 101
fmt.Println("array after modification to slice nums2", numa)
}
运行结果：
array before change 1 [78 79 80]
array after modification to slice nums1 [100 79 80]
array after modification to slice nums2 [100 101 80]
1.4 len() 和 cap() 函数
切片的长度是切片中元素的数量。切片的容量是从创建切片的索引开始的底层数组中元素的数量。
切片是可索引的，并且可以由 len() 方法获取长度
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少
package main
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSlice(numbers)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
运行结果
len=3 cap=5 slice=[0 0 0]
空切片
一个切片在未初始化之前默认为 nil，长度为 0
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
if(numbers == nil){
fmt.Printf("切片是空的")
}
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
运行结果
len=0 cap=0 slice=[]
切片是空的
package main
import "fmt"
func main() {
/* 创建切片 */
numbers := []int{0,1,2,3,4,5,6,7,8}
printSlice(numbers)
/* 打印原始切片 */
fmt.Println("numbers ==", numbers)
/* 打印子切片从索引1(包含) 到索引4(不包含)*/
fmt.Println("numbers[1:4] ==", numbers[1:4])
/* 默认下限为 0*/
fmt.Println("numbers[:3] ==", numbers[:3])
/* 默认上限为 len(s)*/
fmt.Println("numbers[4:] ==", numbers[4:])
numbers1 := make([]int,0,5)
printSlice(numbers1)
/* 打印子切片从索引 0(包含) 到索引 2(不包含) */
number2 := numbers[:2]
printSlice(number2)
/* 打印子切片从索引 2(包含) 到索引 5(不包含) */
number3 := numbers[2:5]
printSlice(number3)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
运行结果
len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]
1.5 append() 和 copy() 函数
append 向slice里面追加一个或者多个元素，然后返回一个和slice一样类型的slice
copy 函数copy从源slice的src中复制元素到目标dst，并且返回复制的元素的个数
append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。 但当slice中没有剩
余空间（即(cap-len) 0）时，此时将动态分配新的数组空间。返回的slice数组指针将指向这个空间，而原
数组的内容将保持不变；其它引用此数组的slice则不受影响
下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法
package main
import "fmt"
func main() {
var numbers []int
printSlice(numbers)
/* 允许追加空切片 */
numbers = append(numbers, 0)
printSlice(numbers)
/* 向切片添加一个元素 */
numbers = append(numbers, 1)
printSlice(numbers)
/* 同时添加多个元素 */
numbers = append(numbers, 2,3,4)
printSlice(numbers)
/* 创建切片 numbers1 是之前切片的两倍容量*/
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* 拷贝 numbers 的内容到 numbers1 */
copy(numbers1,numbers)
printSlice(numbers1)
}
func printSlice(x []int){
fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}
运行结果
len=0 cap=0 slice=[]
len=1 cap=2 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=8 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]
numbers1与numbers两者不存在联系，numbers发生变化时，numbers1是不会随着变化的。也就是说copy方法是不会建立两个切片的联系的
2、笔记及总结
2.1 数组 array, 切片 slice
package main
import "fmt"
func main() {
/*
数组 array
存储一组相同数据类型的数据结构，特点：定长
切片 slice
同数组类型，也叫做变长数组或者动态数组, 特点：变长
是一个引用类型的容器，指向了一个底层数组
make()
func make(t Type, size ...IntegerType) Type
第一个参数：类型
slice,map,chan
第二个参数：长度len
实际存储元素的数量
第三个参数：容量 cap
最多能够存储的元素数量
append() 专门用于向切片的尾部追加元素
slice = append(slice,ele1,ele2)
slice = append(slice,anotherSlice...)
*/
// 数组
arr := [4]int{12, 23, 34, 45}
fmt.Println(arr)
// 切片
var slice1 []int
fmt.Println(slice1)
fmt.Printf("%T,%T\n", slice1, arr)
slice1 = []int{55, 32, 123, 213, 23}
fmt.Printf("%T,%T\n", slice1, arr)
slice2 := make([]int, 3, 5)
fmt.Println(slice2)
fmt.Printf("容量为：%d, 长度为：%d,", cap(slice2), len(slice2))
fmt.Printf("%T,%T\n", slice2, slice1)
slice2[0] = 100
slice2[1] = 200
slice2[2] = 300
fmt.Println(slice2)
// append
slice3 := make([]int, 0, 5)
fmt.Println(slice3)
slice3 = append(slice3, 1)
fmt.Printf("容量为：%d,长度为：%d,", cap(slice3), len(slice3))
fmt.Println()
fmt.Println(slice3)
slice3 = append(slice3, 2, 3, 4, 5, 6, 7)
fmt.Printf("容量为：%d,长度为：%d,", cap(slice3), len(slice3))
fmt.Println()
fmt.Println(slice3)
slice3 = append(slice3, slice2...)
fmt.Println(slice3)
fmt.Printf("容量为：%d,长度为：%d,", cap(slice3), len(slice3))
fmt.Println()
fmt.Print("************************************\n")
// 遍历 一下切片
for key, value := range slice3 {
fmt.Println(key, value)
}
}
2.2 切片引用
package main
import "fmt"
func main() {
/*
切片 Slice
1、每一个切片引用了一个底层数组
2、切片本身不存储任何数据，都是这个底层数组存储，所以修改切片也就是修改这个数组中的数据
3、当向切片中添加数据时，如果没有超过容量，直接添加，如果超过容量，自动扩容（成倍增长）
4、切片一旦扩容，就是重新指向一个新的底层数组
*/
slice1 := []int{1, 2, 3}
fmt.Println(slice1)
fmt.Printf("len:%d,cap:%d\n", len(slice1), cap(slice1))
fmt.Printf("地址：%p\n", &slice1)
slice1 = append(slice1, 10, 123)
fmt.Println(slice1)
fmt.Printf("len:%d,cap:%d\n", len(slice1), cap(slice1))
fmt.Printf("地址：%p\n", &slice1)
slice1 = append(slice1, 11, 22)
fmt.Println(slice1)
fmt.Printf("len:%d,cap:%d\n", len(slice1), cap(slice1))
fmt.Printf("地址：%p\n", &slice1)
slice1 = append(slice1, 33, 44)
fmt.Println(slice1)
fmt.Printf("len:%d,cap:%d\n", len(slice1), cap(slice1))
fmt.Printf("地址%p\n", &slice1)
slice1 = append(slice1, 55, 66, 77, 88)
fmt.Println(slice1)
fmt.Printf("len:%d,cap:%d\n", len(slice1), cap(slice1))
fmt.Printf("地址：%p\n", &slice1)
}
2.3 从已有数组中创建切片
package main
import "fmt"
func main() {
/*
slice := arr[start:end]
切片中的数据： [start,end]
arr[:end]，从头到end
arr[start:]，从start到结尾
从已遥的数组上，直接创建切片，该切片的底层数组就是当前的数组
长度是从start到end切割数据量
但是容量从start到数组的末尾
*/
arr1 := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
fmt.Println("***********************************1、已有数组直接创建切片**********************")
slice1 := arr1[:5]
slice2 := arr1[2:3]
slice3 := arr1[6:]
slice4 := arr1[:]
fmt.Println("slice1 : ", slice1)
fmt.Println("slice2 : ", slice2)
fmt.Println("slice3 : ", slice3)
fmt.Println("slice4 : ", slice4)
fmt.Printf("slice1 = len:%d,cap:%d, 地址：%p\n", len(slice1), cap(slice1), &slice1)
fmt.Printf("slice2 = len:%d,cap:%d, 地址：%p\n", len(slice2), cap(slice2), &slice2)
fmt.Printf("slice3 = len:%d,cap:%d, 地址：%p\n", len(slice3), cap(slice3), &slice3)
fmt.Printf("slice4 = len:%d,cap:%d, 地址：%p\n", len(slice4), cap(slice4), &slice4)
fmt.Println("***********************************2、更改切片的内容**********************")
arr1[0] = 7777
fmt.Println(arr1)
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
fmt.Println("***********************************3、更改切片的内容**********************")
slice2[0] = 888
fmt.Println(arr1)
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
fmt.Println("***********************************4、更改切片的内容**********************")
slice1 = append(slice1, 999, 9999, 99999, 99999)
fmt.Println(arr1)
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
fmt.Printf("slice1 = len:%d,cap:%d, 地址：%p\n", len(slice1), cap(slice1), &slice1)
fmt.Printf("slice2 = len:%d,cap:%d, 地址：%p\n", len(slice2), cap(slice2), &slice2)
fmt.Printf("slice3 = len:%d,cap:%d, 地址：%p\n", len(slice3), cap(slice3), &slice3)
fmt.Printf("slice4 = len:%d,cap:%d, 地址：%p\n", len(slice4), cap(slice4), &slice4)
fmt.Println("***********************************5、更改切片的内容**********************")
slice1 = append(slice1, 4, 4, 4, 4, 4, 4, 4, 4)
fmt.Println(arr1)
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4)
fmt.Printf("slice1 = len:%d,cap:%d, 地址：%p\n", len(slice1), cap(slice1), &slice1)
fmt.Printf("slice2 = len:%d,cap:%d, 地址：%p\n", len(slice2), cap(slice2), &slice2)
fmt.Printf("slice3 = len:%d,cap:%d, 地址：%p\n", len(slice3), cap(slice3), &slice3)
fmt.Printf("slice4 = len:%d,cap:%d, 地址：%p\n", len(slice4), cap(slice4), &slice4)
}
2.4 切片是引用类型的数据，存储了底层数组的引用
package main
import "fmt"
func main() {
/*
按照类型来分：
基本类型：int,float,string,bool
复合类型：array,slice,map,struct,pointer,function,chan
按照特点来分：
值类型：int,float,string,bool,array
传递的是数据副本
引用类型：slice
传递的地址，多个变量指向了同一块内存地址
所以：切片是引用类型的数据，存储了底层数组的引用
*/
str := "雨林之后"
int1 := 888
float1 := 8.88
arr1 := [5]int{1, 2, 3, 4, 5}
// 值传递
arr2 := arr1
fmt.Println(str, int1, float1, arr1, arr2)
arr1[1] = 999
fmt.Println(str, int1, float1, arr1, arr2)
fmt.Printf("arr1 = len:%d,cap:%d,地址：%p\n", len(arr1), cap(arr1), &arr1)
fmt.Printf("arr2 = len:%d,cap:%d,地址：%p\n", len(arr2), cap(arr2), &arr2)
// 切片
slice1 := []int{1, 2, 3, 4, 5}
slice2 := slice1
fmt.Println(slice1, slice2)
slice1[0] = 999
fmt.Println(slice1, slice2)
fmt.Printf("slice1 = len:%d,cap:%d,地址：%p\n", len(slice1), cap(slice1), &slice1)
fmt.Printf("slice2 = len:%d,cap:%d,地址：%p\n", len(slice2), cap(slice2), &slice2)
}
2.5 切片的深拷贝与浅拷贝
package main
import "fmt"
func main() {
/*
深拷贝：拷贝的是数据本身
值类型的数据，默认都是深拷贝：array,int,float,string,bool,struct
浅拷贝：拷贝的是数据地址
导致多个变量指向同一块内存
引用类型的数据，默认都是浅拷贝：slice,map
因为切片是引用类型的数据，直接拷贝的是地址
func copy(dst,src []type) int
可以实现切片的拷贝
*/
slice1 := []int{1, 2, 3, 4, 5}
slice2 := make([]int, 0)
for i := 0; i < len(slice1); i++ {
slice2 = append(slice2, slice1[i])
}
fmt.Println(slice1)
fmt.Println(slice2)
slice1[0] = 100
fmt.Println(slice1)
fmt.Println(slice2)
// copy
slice3 := []int{7, 8, 9}
fmt.Println(slice2)
fmt.Println(slice3)
//
copy(slice3[:], slice2[2:])
fmt.Println(slice2)
fmt.Println(slice3)
}
声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。
评论(0)