Go基础数据结构--切片

1.切片Slice

上一节介绍的数组在 Go 语言中没那么常用，更常用的数据结构是切片，即动态数组，其长度并不固定，我们可以向切片中追加元素，它会在容量不足时自动扩容。

在 Go 语言中，切片类型的声明方式与数组有一些相似，不过由于切片的长度是动态的，所以声明时只需要指定切片中的元素类型：

[]int
[]interface{}

1.0 切片数据结构

type SliceHeader struct {
    
    
	Data uintptr
	Len  int
	Cap  int
}

Data 是指向数组的指针;
Len 是当前切片的长度；
Cap 是当前切片的容量，即 Data 数组的大小；

Data 是一片连续的内存空间，这片内存空间可以用于存储切片中的全部元素，数组中的元素只是逻辑上的概念，底层存储其实都是连续的，所以我们可以将切片理解成一片连续的内存空间加上长度与容量的标识。

1.1 切片定义

切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递。
切片的长度可以改变，因此，切片是一个可变的数组。
切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制。
cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组。
切片的定义：var 变量名 []类型，比如 var str []string var arr []int。
如果 slice == nil，那么 len、cap 结果都等于 0。

2.切片初始化

Go 语言中包含三种初始化切片的方式：

通过下标的方式获得数组或者切片的一部分；
使用字面量初始化新的切片；

使用关键字 make 创建切片：

arr[0:3] or slice[0:3]  // 使用下标初始化
slice := []int{
      
      1, 2, 3}  // 使用字面量初始化
slice := make([]int, 10)  // 使用make关键字

创建切片的各种方式：

扫描二维码关注公众号，回复： 15643531 查看本文章

package main

import "fmt"

func main() {
    
    
   //1.声明切片
   var s1 []int
   if s1 == nil {
    
    
      fmt.Println("是空")
   } else {
    
    
      fmt.Println("不是空")
   }
   // 2.:=
   s2 := []int{
    
    }
   // 3.make()
   var s3 []int = make([]int, 0)
   fmt.Println(s1, s2, s3)
   // 4.初始化赋值
   var s4 []int = make([]int, 0, 0)
   fmt.Println(s4)
   s5 := []int{
    
    1, 2, 3}
   fmt.Println(s5)
   // 5.从数组切片
   arr := [5]int{
    
    1, 2, 3, 4, 5}
   var s6 []int
   // 前包后不包
   s6 = arr[1:4]
   fmt.Println(s6)
}

用append内置函数操作切片（切片追加）

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)

输出结果：

slice a : [1 2 3]
slice b : [4 5 6]
slice c : [1 2 3 4 5 6]
slice d : [1 2 3 4 5 6 7]
slice e : [1 2 3 4 5 6 7 8 9 10]

append ：向 slice 尾部添加数据，返回新的 slice 对象。

拷贝切片
切片的拷贝虽然不是常见的操作，但是却是我们学习切片实现原理必须要涉及的。当我们使用 copy(a, b) 的形式对切片进行拷贝。

	s1 := []int{
    
    1, 2, 3, 4, 5}
    fmt.Printf("slice s1 : %v\n", s1)
    s2 := make([]int, 10)
    fmt.Printf("slice s2 : %v\n", s2)
    copy(s2, s1)
    fmt.Printf("copied slice s1 : %v\n", s1)
    fmt.Printf("copied slice s2 : %v\n", s2)
    s3 := []int{
    
    1, 2, 3}
    fmt.Printf("slice s3 : %v\n", s3)
    s3 = append(s3, s2...)
    fmt.Printf("appended slice s3 : %v\n", s3)
    s3 = append(s3, 4, 5, 6)
    fmt.Printf("last slice s3 : %v\n", s3)

输出结果：

slice s1 : [1 2 3 4 5]
slice s2 : [0 0 0 0 0 0 0 0 0 0]
copied slice s1 : [1 2 3 4 5]
copied slice s2 : [1 2 3 4 5 0 0 0 0 0]
slice s3 : [1 2 3]
appended slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0]
last slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0 4 5 6]

copy ：函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠。

小结：
切片的很多功能都是由运行时实现的，无论是初始化切片，还是对切片进行追加或扩容都需要运行时的支持，需要注意的是在遇到大切片扩容或者复制时可能会发生大规模的内存拷贝，一定要减少类似操作避免影响程序的性能。