切片

切片定义：

切片（slice）是对数组一个连续片段的引用，所以切片是一个引用类型。

注意事项：

切片的长度可以在运行时修改，最小为0，最大为相关数组的长度：切片是一个长度可变的数组。

切片容量：

cap（）

切片声明：

var slice []type (不需要说明长度)

切片初始化：

arr := [5]int{1, 2, 3, 4, 5}   //数组

var sl []int = arr[0:3]    //var sl []int = arr[:]等于完整的arr数组

or:

sl := []int{1, 2, 3, 4, 5}  //声明并初始化了一个切片

切片的组成：

指针、长度(len)、容量(cap)

指针：指向第一个slice元素对应的底层数组元素的内存地址。注：slice的第一个元素不一定就是数组的第一个元素。

用make(）创建一个切片：

slice := make([]type, len, [cap])

ep:

sl := make([]int, 50, 100)  等价于 sl := new([100]int)[0:50]

new()和make()的区别：

new（T）：为每个新的类型T分配一片内存，初始化为0并且返回类型为*T的内存地址：这种方法返回一个指向类型为T，值为0的地址的指针（适用：值类型和结构体）

make（T）：返回一个类型为T的初始值（适用：切片、map和channel）

ep：

arr := new([10]int)  //&[0 0 0 0 0]

arr2 := make([]int, 5)  //[0 0 0 0 0]

切片重组：

sl:=make([]type, start_length, capacity)

改变切片长度（start_length）的过程称之为切片重组reslicing

方法：sl = sl[0:len(sl)+1]

切片可以反复扩展直到占据整个相关数组，如果到len(sl)+1 > capacity则会报错：panic: runtime error: slice bounds out of range

切片的复制：

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

sl_to := make([]int, 10)

new := copy(sl_to, sl_from)  //[1 2 3 0 0 0 0 0 0 0]

coyp函数：第一个参数：to，第二个参数：from， 返回：拷贝的个数。 copy操作流程：把from切片的元素从第一个开始一个一个的拷贝到，to切片里面（to切片也是从第一个元素开始接受的），如果想向一个切片增加一个元素或者一个切片，则需要用到append函数。

切片的追加：

append函数： 第一个参数：被追加的切片；第二个参数：需要追加的数据；返回：被追加后新的切片

注意： append 在大多数情况下很好用，但是如果你想完全掌控整个追加过程，你可以实现一个这样的 AppendByte 方法：

funcAppendByte(slice[]byte,data ...byte) []byte{

        m :=len(slice)

        n := m +len(data)

        if n >cap(slice) {

        // if necessary, reallocate

        // allocate double what's needed, for future growth.

        newSlice :=make([]byte,(n +1) *2)

        copy(newSlice,slice)

        slice= newSlice

    }

    slice=slice[0:n]

    copy(slice[m:n],data)

    returnslice

}

从字符串生成字节切片：

一个字符串本质上是一个字节数组，所以可以像对普通数组那样，生成切片，而字符串生成的数组则就是字节数组。

切片和垃圾回收：

切片的底层指向一个数组，该数组的实际体积可能要大于切片所定义的体积。只有在没有任何切片指向的时候，底层的数组内层才会被释放，这种特性有时会导致程序占用多余的内存。

append 函数常见操作：

将切片 b 的元素追加到切片 a 之后：a = append(a, b...)  //这里三个点表示把b切片的所有数据追加到a切片后面

复制切片 a 的元素到新的切片 b 上：

b =make([]T,len(a))copy(b, a)

删除位于索引 i 的元素：a = append(a[:i], a[i+1:]...)

切除切片 a 中从索引 i 至 j 位置的元素：a = append(a[:i], a[j:]...)

为切片 a 扩展 j 个元素长度：a = append(a, make([]T, j)...)

在索引 i 的位置插入元素 x：a = append(a[:i], append([]T{x}, a[i:]...)...)

在索引 i 的位置插入长度为 j 的新切片：a = append(a[:i], append(make([]T, j), a[i:]...)...)

在索引 i 的位置插入切片 b 的所有元素：a = append(a[:i], append(b, a[i:]...)...)

取出位于切片 a 最末尾的元素 x：x, a = a[len(a)-1], a[:len(a)-1]

将元素 x 追加到切片 a：a = append(a, x)

使用slice时需要注意的问题：

arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

s1 := arr[2:6]

s2 := arr[5:10]

s2[0] = 99

fmt.Println(s1, s2)  // [3 4 5 99] [99 7 8 9 10] 可以看出s1和s2的重叠部分会在其中一个改变时改变。

但是：

arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

s1 := arr[2:6]

s2 := arr[5:10]

s1 = append(s1, 1, 2, 3, 4, 5, 6, 7, 8, 9)

s2[0] = 99

fmt.Println(s1, s2) 

输出：

[3 4 5 6 1 2 3 4 5 6 7 8 9] [99 7 8 9 10] 

可以看出，s1之前和s2重叠部分的数据没有随s2的改变而改变，因为，append在给s1增加元素时已经超出了s1的容量，所以重新为s1分配了一块连续的内存，此时s1和s2指向已经不是同一块内存中的数组了，所以s2的改变时无法影响s1了。

删除slice中指定的元素

因为slice引用指向底层数组，数组的长度不变元素是不能删除的，所以删除的原理就是排除待删除元素后用其他元素重新构造一个数组

func  deleteByAppend (i int) []int { 

      i :=3

      s := []int{1,2,3,4,5,6,7}

      s = append(s[:i], s[i+1:]...)

       return s

}

func  deleteByCopy (i int) []int {    

       s := []int{1,2,3,4,5,6,7}

       copy(s[i:], s[i+1:])    

        s = s[:len(s)-1]

        return s

}