package main

/*
切片Slice
其本身并不是数组，它指向底层的数组
作为变长数组的替代方案，可以关联底层数组的局部或全部
为引用类型
可以直接创建或从底层数组获取生成
使用len()获取元素个数，cap()获取容量
一般使用make()创建
如果多个slice指向相同底层数组，其中一个的值改变会影响全部
make([]T, len, cap)
其中cap可以省略，则和len的值相同
len表示存数的元素个数，cap表示容量

用new创建数组的时候是一个指向数组的指针。
*/

import (
    "fmt"
)

func main() {
    var slice1 []int //中括号里面是数字或者3个点就表示数组，
    //中括号里面既不是数字也不是3个点就表示是slice不是数组
    fmt.Println(slice1) //[],slice的底层也是数组保存的，打印也是数组的格式，

    a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(a) //[1 2 3 4 5 6 7 8 9 0]

    s1 := a[2]      //一个slice
    fmt.Println(s1) //3

    s2 := a[5:10]   //数组的索引从5到9，包头不包尾，//一个slice
    fmt.Println(s2) //[6 7 8 9 0]

    s3 := a[5:len(a)] //数组的索引从5到长度减一，包头不包尾，//一个slice
    fmt.Println(s3)   //[6 7 8 9 0]

    s4 := a[5:]     //数组的索引从5到尾部，//一个slice
    fmt.Println(s4) //[6 7 8 9 0]

    s5 := a[:5]     //数组的索引从开头到索引为4，//一个slice
    fmt.Println(s5) //[1 2 3 4 5]

    s11 := make([]int, 3) //初始化3个元素，并放在slice所指向的数组中，
    fmt.Println(s11)      //    [0 0 0]

    s22 := make([]int, 3, 10) //初始化3个元素，slice指向的是一个数组，数组是一块连续的内存,
    //数组不能动态修改长度， 10第三个参数是数组的容量，现在是3个，但是总共可以有10个，当超出10个后
    //会重新分配连续的内存块（内存地址改变了）（重新分配内存的效率低），并且容量扩大一倍成20，
    fmt.Println(s22)                //    [0 0 0]
    fmt.Println(len(s22), cap(s22)) //    3,10

    //slice是引用类型的并且可以扩容的数组

    a1 := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'}
    s33 := a1[2:5]           //一个slice
    fmt.Println(s33)         //    [99 100 101]
    fmt.Println(string(s33)) //    cde

    /*
        Reslice
        Reslice时索引以被slice的切片为准
        索引不可以超过被slice的切片的容量cap()值
        索引越界不会导致底层数组的重新分配而是引发错误
    */
    //从slice中获取slice
    s44 := s33[1:3]          //一个slice
    fmt.Println(s44)         //[100 101]
    fmt.Println(string(s44)) //de

    /*
        Append
        可以在slice尾部追加元素
        可以将一个slice追加在另一个slice尾部
        如果最终长度未超过追加到slice的容量则返回原始slice
        如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据
    */

    s55 := make([]int, 3, 6)        //3个元素容量为6的slice
    fmt.Printf("%v,%p\n", s55, s55) //[0 0 0],0xc04200e2a0
    s55 = append(s55, 1, 2, 3)
    fmt.Printf("%v,%p\n", s55, s55) //[0 0 0 1 2 3],0xc04200e2a0,没有超过容量不重新分配内存地址
    s55 = append(s55, 1, 2, 3)
    fmt.Printf("%v,%p\n", s55, s55) //[0 0 0 1 2 3 1 2 3],0xc04203a120，超过容量重新分配内存地址

    a2 := [...]int{1, 2, 3, 4, 5}
    s66 := a2[2:5] //[3 4 5],不显示的加容量，则容量就是此时slice中元素的个数3，
    s77 := a2[1:3] // [2 3]
    fmt.Println(s66, s77)
    s66[0] = 9
    fmt.Println(s66, s77) //[9 4 5] [2 9],slice指向一个底层的数组，其中一个改变另外一个也改变，
    //如果超过slice的容量会重新分配内存，此时改变这个slice其他的slice就不会改变了
    s66 = append(s66, 1, 2, 3, 2, 3, 2, 3, 4, 3, 4)
    s66[0] = 99
    fmt.Println(s66, s77) //[99 4 5 1 2 3 2 3 2 3 4 3 4] [2 9]

    //slice的copy函数
    s88 := []int{1, 2, 3, 4, 5, 6}
    s99 := []int{7, 8, 9}
    copy(s88, s99)        //左边是拷贝到的元素，后面是被拷贝的元素，吧前三个元素拷贝到s88的前三个
    fmt.Println(s88, s99) //[7 8 9 4 5 6] [7 8 9]

    ss11 := []int{1, 2, 3, 4, 5, 6}
    ss22 := []int{7, 8, 9}
    copy(ss22, ss11)
    fmt.Println(ss11, ss22) //[1 2 3 4 5 6] [1 2 3]，ss22只有3个元素，则只接收3个元素逇拷贝

    ss33 := []int{1, 2, 3, 4, 5, 6}
    ss44 := []int{7, 8, 9}
    copy(ss33, ss44[1:2])      //部分拷贝
    copy(ss33[2:4], ss44[1:2]) //指定拷贝到哪里
    fmt.Println(ss33, ss44)    //[1 2 3 4 5 6] [1 2 3]，ss22只有3个元素，则只接收3个元素逇拷贝

}