Golang 切片

★切片的基本介绍

1）切片的英文是slice

2）七篇是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。

3）切片的使用和数组类似，遍历切片、访问切片的元素和求切片的长度len（slice）都一样。

4）切片的长度是可以变化的。因此切片是一个可以动态变化数组。

5）切片定义的基本语法：

　　var 变量名 []类型

　　比如： var a []int

package main

import (
    "fmt"
)

func main() {
    //演示切片的使用
    //切片的来源是数组，首先要存在数组
    var intArr [5]int = [...]int {1,22,33,44,66}
    //声明定义一个切片
    //slice := intArr[1:3]
    //1. slice 就是切片名
    //2. intArr[1:3] 表示 slice 引用到intArr这个数组
    //3. 引用intArr数组的起始下标为 1， 最后的下标为3（但是不包含3）
    slice := intArr[1:3]
    fmt.Println("intArr = ",intArr)
    fmt.Println("slice 的元素是 = ",slice)
    fmt.Println("slice 的元素个数 = ",len(slice))
    fmt.Println("slice 的容量 =",cap(slice))
}

★切片的使用

方式1

第一种方式：定义一个切片，然后让切片去引用一个已经创建好的数组，比如前面的案例就是这样的。

方式2

第二种方式：通过make来创建切片。

基本语法：

　　 var 切片名 []type = make([],len,[cap])

参数说明：

　　type：就是数据类型

　　len：大小

　　cap：指定切片容量，可选

import (
    "fmt"
)

func main() {
    //演示切片的使用 make
    var slice []float64 = make([]float64,5,10)
    slice[1] = 10
    slice[3] = 20
    //对于切片必须make使用
    fmt.Println(slice)
    fmt.Println("slice的size=",len(slice))
    fmt.Println("slice的cap=",cap(slice))
}

方式3

第三种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式

import (
    "fmt"
)

func main() {
    //演示切片的使用，直接定义

    var slice []int = []int {1,3,5}
    fmt.Println(slice)
}

方式1和方式2的区别（面试）

方式1是直接应用数组，这个数组是事先存在的，程序员是可见的。

方式2是通过马克来创建切片，make也会创建一个数组，是由切片在底层进行维护，程序员是看不见的。

★切片的遍历

切片的遍历和数组一样，也由两种方式

方式1：for循环常规遍历

import (
    "fmt"
)

func main() {
    //使用常规的for循环遍历切片
    var arr [5]int = [...]int{10,20,30,40,50}
    slice := arr[1:4]
    for i :=0;i< len(slice); i++{
        fmt.Printf("slice[%v]=%v",i,slice[i])
    }

}

 

方式2：for-range结构遍历切片

import (
    "fmt"
)

func main() {

    //使用for-range 方式遍历切片
    for i,v := range slice{
        fmt.Printf("i=%v v=%v \n",i,v)
    }
}

★切片注意事项和细节说明

1）切片初始化时，var slice = arr[startIndex:endIndex]

　　说明：从arr数组洗标为startIndex，取到下标为endIndex的元素（不含arr[endIndex]）。

2）切片初始化时，仍然不能越界。范围在[0-len(arr)]之间，但是可以动态增长。

　　2.1）var slice = arr[0:end] 可以简写 var slice = arr[:end]

　　2.2）var slice = arr[start:len(arr)] 可以简写：var slice = arr[start:]

　　2.3）var slice = arr[0:len(arr)] 可以简写： var slice = arr[:]

3）cap是一个内置函数，用于统计切片的容量，即最大可以存放多少个元素。

4）切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用

5）切片可以继续切片

6）用append内置函数，可以对切片进行动态追加

import (
    "fmt"
)
func main() {
    var arr [5]int = [5]int {1,2,3,4,5}
    var slice = arr[:]
    //追加具体的元素
    slice = append(slice, 10,20,30)
    fmt.Println("slice",slice)

    //在切片上追加切片
    var a = []int{100,200}
    slice = append(slice, a...)
    fmt.Println("slice",slice)
    
}

切片append操作的底层原理分析：

①切片append曹的本质就是对数组扩容

②go底层会创建一下新的数组newArr（安装扩容后大小）

③将slice原来包含的元素拷贝到新的数组newArr

④slice重新引用到newArr

⑤注意newArr是在底层来维护的，程序员不可见

7）切片的拷贝操作

切片使用copy内置函数完成拷贝

import (
    "fmt"
)

func main() {

    //将a拷贝到slice
    var a []int = []int{1,2,3,4,5}
    var slice = make([]int,10)
    fmt.Println(slice)
    copy(slice,a)
    fmt.Println(slice)
}

说明：copy(part1,part2):part1和part2都是切片类型。

★切片的遍历

切片的遍历有两种方式

方式1 ：for循环常规方式

import (
    "fmt"
)

func main() {
    //使用常规for循环遍历切片
    var   arr [5]int = [...]int{10,20,30,40,50}
    slice := arr[1:4]
    for i :=0;i < len(slice); i++{
        fmt.Printf("slice[%v]=%v",i,slice[i])
    }
}

方式2：for-range方式

import (
    "fmt"
)

func main() {

    //使用for-ange 方式遍历切片
    for  i, v := range slice {
        fmt.Printf("i=%v v=%v \n",i,v)
    }
}

 ★string和slice区别

1）string底层是一个byte数组，因此string也可以进行切片处理

import (
    "fmt"
)
func main() {
    //string底层是一个byte数组，因此string也可以进行切片处理
    str := "hello@ckfuture"
    //使用切片获取到ckfuture
    slice := str[6:]
    fmt.Println("slice",slice)    
}

2）string和切片在内存的形式

3）string是不可变的，也就是说不能通过str[0]='z'方式来修改字符串

4）如果需要修改字符串，可以先将string->[]byte或者[]rune->修改->重写转成string

import (
    "fmt"
)
func main() {
    //string是不可变的，也就说不能通过 str[0]='z' 方式来修改字符串
    //str[0] = 'z'

    //如果需要修改字符串，可以先将string-》[]byte 或者[]rune-》修改->重写转成string
    //"hello@ckfuture"->改成"zello@ckfuture"
    arr1 := []byte(str)
    arr1[0] = 'z'
    str = string(arr1)
    fmt.Println("str = ",str)
}

import (
    "fmt"
)

func main() {
    //string底层是一个byte数组，因此string也可以进行切片处理
    str := "hello@ckfuture"

    //细节，我们转换成[]byte后，可以处理英文和数字，但是不能处理中文
    //原因是[]byte 字节来处理，而一个汉字是3个字节，因此就会出现乱码
    //解决办法是 将string转成[]rune即可，因为[]rune是按字符处理，兼容汉字

    arr1 := []rune(str)
    arr1[0] '北'
    str = string(arr1)
    fmt.Println("str = ",str)

}