GO—— 数组的兄弟---切片

目录

GO 切片

1，定义切片

2，切片初始化

3，len() 和 cap() 函数

4，空（nil）切片

5，切片截取

6，append() 和 copy() 函数

---

GO 切片

切片是对数组的抽象。

数组的长度不可改变,在特定场最中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片 ("动态数组")，与数组相比切片的长度是不固定的，可以追加元索,在追加时可能使切片的容量增大。

切片是引用类型。

1，定义切片

可以声明一个未指定大小的数组来定义切片:

var identifier []type

切片不需要说明长度。 或使用make()函数来创建切片:

var slice1 []type = make([]type, len)
​
也可以简写为
​
slice1 := make([]type, len)

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

2，切片初始化

s :=[] int {1,2,3 } 

切片和数组

package main
​
import "fmt"
​
func main() {
    a := []int{4, 5, 6, 7, 8}
    b := [...]int{1, 2, 3, 4, 5}
    fmt.Println(a)
    fmt.Printf("切片类型：%T\n", a)
    fmt.Println(b)
    fmt.Printf("数组类型：%T\n", b)
}
[Running] go run "f:\goProject\src\dev_code\day12\example6\main\main.go"
[4 5 6 7 8]
切片类型：[]int  //切片长度不固定
[1 2 3 4 5]
切片类型：[5]int  //数组长度固定

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

s := arr[:] 

初始化切片 s，是数组 arr 的引用。

s := arr[startIndex:endIndex] 

示例：

package main
​
import "fmt"
​
func main() {
    a := []int{4, 5, 6, 7, 8}
    b := [...]int{1, 2, 3, 4, 5}
    //来自数组的切片
    a1 := b[:]
    fmt.Println(a)
    fmt.Printf("切片类型：%T\n", a)
    fmt.Println(b)
    fmt.Printf("数组类型：%T\n", b)
    fmt.Println(a1)
    fmt.Printf("a1类型：%T\n", a1)
}
[Running] go run "f:\goProject\src\dev_code\day12\example6\main\main.go"
[4 5 6 7 8]
切片类型：[]int    //切片类型
[1 2 3 4 5]
数组类型：[5]int  //数组类型
[1 2 3 4 5]
a1类型：[]int  //切片类型

将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:] 

默认 endIndex 时将表示一直到arr的最后一个元素。

s := arr[:endIndex] 

默认 startIndex 时将表示从 arr 的第一个元素开始。

s1 := s[startIndex:endIndex] 

示例：

package main
​
import "fmt"
​
func main() {
    b := [...]int{1, 2, 3, 4, 5}
    //来自数组的切片
    //从下标1开始取到最后
    c := b[1:]
    //从前取到下标为2的位置
    c1 := b[:3]
    //从第二个元素到第四个元素
    c2 := b[1:4]
​
    fmt.Println(c)
    fmt.Println(c1)
    fmt.Println(c2)
}
[Running] go run "f:\goProject\src\dev_code\day12\example6\main\main.go"
[2 3 4 5]
[1 2 3]
[2 3 4]   //取值是前开后闭的

通过切片 s 初始化切片 s1。

s :=make([]int,len,cap) 

通过内置函数 make() 初始化切片s，[]int 标识为其元素类型为 int 的切片。

3，len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

初始长度:默认放值的数量 容量:切片的最多数值的数量

以下为具体实例：

package main
​
import "fmt"
​
func main() {
    aa := make([]int, 3, 6)
    PrionInfo(aa)
}
​
func PrionInfo(a []int) {
    fmt.Printf("切片的长度%d,切片的容量%d,切片的结构%v\n", len(a), cap(a), a)
}
[Running] go run "f:\goProject\src\dev_code\day12\example7\main\main.go"
切片的长度3,切片的容量6,切片的结构[0 0 0]
​
[Done] exited with code=0 in 0.463 seconds

4，空（nil）切片

一个切片在未初始化之前默认为nil,长度为0 示例:

p

ackage main
​
import "fmt"
​
func main() {
    aa := make([]int, 3, 6)
    PrionInfo(aa)
    //定义空切片
    var aaa []int
    PrionInfo(aaa)
    if aaa == nil {
        fmt.Println("aaa是空切片")
    }
}
​
func PrionInfo(a []int) {
    fmt.Printf("切片的长度%d,切片的容量%d,切片的结构%v\n", len(a), cap(a), a)
}
[Running] go run "f:\goProject\src\dev_code\day12\example7\main\main.go"
切片的长度3,切片的容量6,切片的结构[0 0 0]
切片的长度0,切片的容量0,切片的结构[]
aaa是空切片

5，切片截取

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]，实例如下：

package main
​
import "fmt"
​
func main() {
    /* 创建切片 */
    aaa := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
    printSlice(aaa)
​
    /* 打印原始切片 */
    fmt.Println("aaa ==", aaa)
​
    /* 打印子切片从索引1(包含) 到索引4(不包含)*/
    fmt.Println("aaa[1:4] ==", aaa[1:4])
​
    /* 默认下限为 0*/
    fmt.Println("aaa[:3] ==", aaa[:3])
​
    /* 默认上限为 len(s)*/
    fmt.Println("aaa[4:] ==", aaa[4:])
​
    aaa1 := make([]int, 0, 5)
    printSlice(aaa1)
​
    /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
    aaa2 := aaa[:2]
    printSlice(aaa2)
​
    /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
    //切片的起始位置决定容量，起始位置之前的容量切片会丢弃
    aaa3 := aaa[2:5]
    printSlice(aaa3)
​
}
​
func printSlice(x []int) {
    fmt.Printf("长度=%d 容量=%d 切片=%v\n", len(x), cap(x), x)
}
[Running] go run "f:\goProject\src\dev_code\day12\example8\main\main.go"
长度=9 容量=9 切片=[0 1 2 3 4 5 6 7 8]
aaa == [0 1 2 3 4 5 6 7 8]
aaa[1:4] == [1 2 3]
aaa[:3] == [0 1 2]
aaa[4:] == [4 5 6 7 8]
长度=0 容量=5 切片=[]
长度=2 容量=9 切片=[0 1]    
长度=3 容量=7 切片=[2 3 4] //切片的起始位置决定容量，起始位置之前的容量切片会丢弃

切片的起始位置决定容量，起始位置之前的容量切片会丢弃

6，append() 和 copy() 函数

如果想增加切片的容量，我们必须创建一个新的更大的切片并把原分片的内容都拷贝过来。

下面的代码描述了从拷贝切片的 copy 方法和向切片追加新元素的 append 方法。

package main
​
import "fmt"
​
func main() {
    //原始切片
    var aaa []int
    fmt.Println("原始 aaa=",aaa)
    printSlice(aaa)
    //追加元素
    aaa = append(aaa, 1)
    fmt.Println("第一次追加 aaa=", aaa)
    printSlice(aaa)
    aaa = append(aaa, 2, 3, 4)
    fmt.Println("第二次追加 aaa=", aaa)
    printSlice(aaa)
    //创建更大容量的切片,使新的切片扩大一倍
    aaa1 := make([]int, len(aaa), (cap(aaa))*2)
    //切片复制，新切片名在前，原始切片名字在后
    copy(aaa1, aaa)
    fmt.Println("切片复制 aaa1=", aaa1)
    printSlice(aaa1)
​
}
func printSlice(x []int) {
    fmt.Printf("长度=%d 容量=%d 切片=%v\n", len(x), cap(x), x)
}
[Running] go run "f:\goProject\src\dev_code\day12\example9\main\main.go"
原始 aaa= []
长度=0 容量=0 切片=[]
第一次追加 aaa= [1]
长度=1 容量=1 切片=[1]
第二次追加 aaa= [1 2 3 4]
长度=4 容量=4 切片=[1 2 3 4]
切片复制 aaa1= [1 2 3 4]
长度=4 容量=8 切片=[1 2 3 4]