切片

1.切片(slice)是golang中一种特有的数据类型

2.数组有特定的用处，但是却有一些呆板(数组长度固定不可变)，所以在 Go 语言的代码里并不是特别常见。相对的

切片却是随处可见的，切片是一种建立在数组类型之上的抽象，它构建在数组之上并且提供更强大的能力和便捷。

3切片(slice)是对数组一个连续片段的引用，所以切片是一个引用类型。这个片段可以是整个数组，或者是由起始和终

止索引标识的一些项的子集。需要注意的是，终止索引标识的项不包括在切片内。切片提供了一个相关数组的动态窗

口。

package main

import "fmt"

func main() {
    //定义数组
    var intarr [5]int = [5]int{1, 2, 3, 4, 5}
    //定义一个切片，切片构建在数组上
    var slice []int = intarr[1:3]
    fmt.Println("intarr:", intarr)
    fmt.Println("slice:", slice)
    //使用内置函数len输出slice的长度
    fmt.Println("slice的长度:", len(slice))
    //使用cap内置函数输slice的容量，切片的容量动态变化
    fmt.Println("slice的容量:", cap(slice))

    fmt.Println("intarr[1]:", &intarr[1])
    fmt.Println("slice]:", &slice[0])
    slice[1] = 99
    fmt.Println("intarr:", intarr)
    fmt.Println("slice:", slice)
}

//结果：
//intarr: [1 2 3 4 5]
//slice: [2 3]
//slice的长度: 2
//slice的容量: 4
//intarr[1]: 0xc00000e368
//slice]: 0xc00000e368
//intarr: [1 2 99 4 5]
//slice: [2 99]

内存关系：

切片的定义

1.方式1:定义一个切片，然后让切片去引用一个已经创建好的数组。

2.方式2:通过make内置函数来创建切片。

基本语法: var切片名[type= make(0,len,[cap])

make底层创建一个数组，对外不可见，只能通过切片对数组进行操作

3.方式3:定一个切片，直接就指定具体数组，使用原理类似make的方式。

package main

import "fmt"

func main() {
    //数组初始化
    //第一种
    var intarray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var slice []int = intarray[2:6]
    fmt.Println(slice, len(slice), cap(slice))

    //第二种
    //make函数的三哥参数（切片类型，切片长度，切片容量）
    slice1 := make([]int, 10, 30)
    slice1[5] = 66
    slice1[8] = 99
    fmt.Println(slice1, len(slice1), cap(slice1))

    //第三种
    slice2 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(slice2, len(slice2), cap(slice2))
}
//结果：
//[3 4 5 6] 4 8
//[0 0 0 0 0 66 0 0 99 0] 10 30
//[1 2 3 4 5 6 7 8 9 10] 10 10

切片的遍历

1.for循环遍历

2.for-range遍历

package main

import "fmt"

func main() {
    var intarr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var slice1 []int = intarr[5:8]
    var slice2 []int = intarr[2:5]
    //for循环遍历
    for i := 0; i < len(slice1); i++ {
       fmt.Printf("%v\t%v\n", i, slice1[i])
    }
    fmt.Println("************************************")
    //for range 遍历
    for i, j := range slice2 {
       fmt.Printf("%v\t%v\n", i, j)
    }
}

//运行结果
//0 6
//1 7
//2 8
//************************************
//0 3
//1 4
//2 5

切片的注意事项

1.切片定义后不可以直接使用，需要让其引用到一个数组，或者make一个空间供切片来使用

package main

import "fmt"

func main() {
    var slice []int
    fmt.Println(slice)
}
//运行结果：
//[]

2.切片使用不能越界。切片索引不能超出范围

package main

import "fmt"

func main() {
    var intarr [5]int = [5]int{1, 2, 3, 4, 5}
    var slice []int = intarr[1:3]
    fmt.Println(slice[0])
    fmt.Println(slice[1])
    fmt.Println(slice[2])
}

3.简写方式:

1)var slice = arr[0:end]----》 var slice = arr[:end]

2)var slice =arr[start:len(arr)]----》var slice = arr[start:]

3)var slice = arr[0:len(arr)]----》var slice = arr[:]

4.切片可以继续切片

package main

import "fmt"

func main() {
    var intarr [5]int = [5]int{1, 2, 3, 4, 5}
    var slice []int = intarr[1:4] //2,3,4
    //对切片进行切片
    var slice1 []int = slice[1:2] //3
    fmt.Println(slice1)
    slice1[0] = 66
    fmt.Println(slice)
}

//运行结果：
//[3]
//[2 66 4]

5.通过append函数实现切片的动态增加

package main

import "fmt"

func main() {
    var intarr [5]int = [5]int{1, 2, 3, 4, 5}
    var slice []int = intarr[1:4] //2,3,4
    fmt.Println(slice)
    fmt.Println("**************")
    //append在底层创建一个新的数组
    //把slice数组内容复制过去后再添加内容
    slice = append(slice, 996)
    fmt.Println(slice)
    fmt.Println("**************")
    slice1 := []int{88, 66}
    slice = append(slice, slice1...)
    fmt.Println(slice)
}
//运行结果：
//[2 3 4]
//**************
//[2 3 4 996]
//**************
//[2 3 4 996 88 66]

切片的拷贝

package main

import "fmt"

func main() {
    var i []int = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var j = make([]int, 20)
    //复制切片i中内容给j
    copy(j, i)
    fmt.Println(j)
}
//运行结果：
//[1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0]