Go语言之切片

一、切片简介

　　为什么需要切片呢？我们知道数组的大小一旦确定下来就不能改变了，那么如果存放一些个数不确定的值，数组就不能使用了，这时候就需要切片，切片可以当作动态数组来使用。

• 切片的使用和数组类似，查询切片的长度、遍历切片等操作
• 切片是引用类型，它是数组的一个引用，在进行传递时，遵循引用传递的机制
• 切片是动态数组，长度是可变的

切片的基本语法：

　　var 切片名称 []类型

　　如：var s1 [] int

package main

import "fmt"

func main() {

    // 定义一个数组
    var a [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println(a) // [1 2 3 4 5]

    // 定义一个切片，引用上面的数组
    var s1 = a[0:3]
    fmt.Println(s1) // [1 2 3]
    fmt.Println("切片的个数", len(s1)) // 片的个数 3
    fmt.Println("切片的动态容量", cap(s1)) // 切片的动态容量 5
    
}

二、切片的创建

1、方式一

这种方式就是上面简介使用的一种方式，创建一个数组，然后让定义好的切片去引用该数组。

package main

import "fmt"

func main() {

    // 定义一个数组
    var a [5]int = [5]int{1, 2, 3, 4, 5}
    fmt.Println(a) // [1 2 3 4 5]

    // 定义一个切片，引用上面的数组
    var s1 = a[0:3]
    fmt.Println(s1) // [1 2 3]
    fmt.Println("切片的个数", len(s1)) // 片的个数 3
    fmt.Println("切片的动态容量", cap(s1)) // 切片的动态容量 5
    
}

2、方式二

通过make来创建切片：var 切片名称 []type = make([]type, len, [cap])

• type 数据类型
• len 大小
• cap 切片容量（可选）。如果分配了cap，则要求cap >= len

package main

import "fmt"

func main() {

    var s2 []int = make([]int, 3, 10)
    s2[0] = 1
    s2[1] = 2

    fmt.Println(s2) // [1 2 0] ，长度为3初始值都默认是0
    
}

• 通过make方式创建切片可以指定切片的大小和容量
• 如果没有给切片的元素赋值，就会使用默认值 int,float都是0，string为“”，bool为false
• 通过make方式创建的切片对应的数组是由make底层维护，只能通过slice访问，外部不可见

3、方式三 

定义一个切片，直接指定具体数组。

package main

import "fmt"

func main() {

    // 定义一个切片，直接指定具体数组，类似make
    var s3 []string = []string{"zhangsan", "lisi", "wangwu"} 

    fmt.Println("s3 =", s3) // s3 = [zhangsan lisi wangwu]
    fmt.Println("len =", len(s3)) // len = 3
    fmt.Println("cap =", cap(s3)) // cap = 3

}

4、总结

方式一与方式三的区别在于方式一是在已经存在的数组上面进行切片，也就是说数组是可见的；方式三通过make的方式创建切片，这对于开发者来说是不可见的。

三、切片的遍历

1、for循环

package main

import "fmt"

func main() {

    var s4 []string = []string{"zhangsan", "lisi", "wangwu"} 

    for i := 0; i < len(s4); i++ {

        fmt.Println(i, s4[i])

    }

}

2、for-range遍历

package main

import "fmt"

func main() {

    var s4 []string = []string{"zhangsan", "lisi", "wangwu"} 

    for i, v := range s4 {

        fmt.Println(i, v)

    }

}

四、动态扩容append

 　　append内置函数，可以对切片进行动态添加，它的本质就是对数组进行扩容。go底层会创建一个新的数组newArr(扩容后的大小)，将切片slice原来包含的元素拷贝到新的数组newArr中，切片slice重新引用新的数组newArr。而旧的数组就会被回收。

实例：

package main

import "fmt"

func main() {

    // 声明一个切片
    var s5 []int = []int{1, 2, 3, 4, 5}
    fmt.Println(s5) // [1 2 3 4 5]

    // 通过append给切片s5追加元素
    s5 = append(s5, 6, 7, 8, 9) 
    fmt.Println(s5) // [1 2 3 4 5 6 7 8 9]

    // 通过append追加切片给s5
    s5 = append(s5, s5...) 
    fmt.Println(s5) // [1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9]

}

五、切片拷贝copy

切片的拷贝通过内置函数copy完成：

• copy(para1, para2)，其中参数para1，para2时切片类型
• 拷贝的和被拷贝的切片空间时独立的、互不影响的，比如下面实例中切片s6_1, s6_2是独立的

package main

import "fmt"

func main() {

    // 声明一个切片
    var s6_1 []int = []int{1, 2, 3, 4, 5}
    
    // 初始化一个切片,默认整型的值都是0
    var s6_2 = make([]int, 10)

    // 将s6_1中的值拷贝到s6_2中
    copy(s6_2, s6_1)

    fmt.Println(s6_1) // [1 2 3 4 5]
    fmt.Println(s6_2) // [1 2 3 4 5 0 0 0 0 0]

}

六、string和slice

上面说的都是基于数组的切片，实际上string也是可以切片的，因为string的底层就是一个byte数组，所以它也是可以切片的。

package main

import "fmt"

func main() {

    str7 := "abcdef" // 在内存中以字节数组的形式存在，[6]byte

    // 使用切片获取到abc
    s7 := str7[0:3]

    fmt.Println(s7) // abc

}

需要注意的时string是不可变的数据类型，因此不能通过赋值的方式str7[0] = 'h'这种方式进行修改值。如果需要修改值则需要通过 string-->[]byte或者[]rune-->修改值-->转成string 这样的方式来实现。

package main

import "fmt"

func main() {

    str8_1 := "abcdef" 

    // 通过 string-->[]byte方式修改值，但是不能处理中文字符，否则乱码，因为byte是按字节处理，而一个汉字三个字节
    s8_1 := []byte(str8_1)
    s8_1[0] = 'h'
    str8_2 := string(s8_1)
    fmt.Println(str8_2) // hbcdef

    // string-->[]rune, 可以处理中文问题
    s8_3 := []byte(str8_1)
    s8_3[0] = 'f'
    s8_4 := string(s8_3)
    fmt.Println(s8_4) // fbcdef

}

七、注意事项

• 切片初始化时 var slice = arr[startIndex:endIndex]左取右不取
• 切片初始化时，不能越界。范围仍旧在[0, len[arr]]之间，但可以动态增长
• cap用于统计切片容量，即最大可以存放多少个元素
• 切片定义后，不能立马使用，因为本身是一个空的，需要引用一个数组，或者make一个空间供切片使用
• 切片可以进行链式切片（切片后可以接着切片）