15.Go_Slice(切片)

Go 切片

Go 语言切片是对数组的抽象。
Go 数组的长度不可改变。

定义切片

声明一个未指定大小的数组来定义切片:
var identifier []type

切片不需要说明长度
或使用make()函数来创建切片:
// len 是数组的长度并且也是切片的初始长度
var slice1 []type = make([]type, len)
简写:
slice1 := make([]type, len)

指定容量，其中capacity为可选参数。
make([]T, length, capacity)

切片初始化

//直接初始化切片
//[]表示是切片类型
//初始化值一次是1,2,3
//cap = len = 3
s := []int {1,2,3}

//初始化切片s,是数组arr的引用
s := arr[:]

将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片
s := arr[startIndex:endIndex] 

//缺省endIndex时将表示一直到arr的最后一个元素
s := arr[startIndex:] 

//缺省startIndex时将表示从arr的第一个元素开始
s := arr[:endIndex] 

//通过切片s初始化切片s1
s1 := s[startIndex:endIndex] 

//通过内置函数make()初始化切片s,[]int 标识为其元素类型为int的切片
s :=make([]int,len,cap) 

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)切片

一个切片在为初始化之前默认为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=[]
切片是空的

切片拦截

通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]

例如:
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(不包含)
    numbers2 := numbers[:2]
    printSlice(numbers2)
    //打印子切片从索引2包含 到索引5(不包含)
    numbers3 := numbers[2:5]
    printSlice(numbers3)
}
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]

append() 和copy()函数

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

例如:
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=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]