谈一谈Go的切片Slice的使用方法

ゝ一纸荒年。 2022-06-02 23:45 239阅读 0赞

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

package main
    
    import "fmt"
    
    func main() {
    var s1 []int //中括号里没有数字或3个点，即表示切片，而不是数组
    fmt.Println(s1)
    }

输出：

[]

package main
    
    import "fmt"
    import "strconv"
    
    func main() {
    a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(a)
    s1 := a[9] //取第10个元素，因为没赋值，默认为0
    s2 := a[5:10] //取后5个元素(即第6个到第10个),注意起始位有包含，截止位没包含
    s3 := a[5:len(a)] //取后5个元素(即第6个到第10个),注意起始位有包含，截止位没包含
    s4 := a[5:] //取后5个元素(即第6个到第10个),注意起始位有包含，截止位没包含
    s5 := a[:5] //取前5个元素,注意起始位有包含，截止位没包含
    fmt.Println("取第10个元素(因为没赋值，默认为0)：" + strconv.Itoa(s1))
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
    fmt.Println(s5)
    }

[1 2 3 4 5 6 7 8 9 0]
      取第10个元素(因为没赋值，默认为0)：0
      [6 7 8 9 0]
      [6 7 8 9 0]
      [6 7 8 9 0]
      [1 2 3 4 5]

package main
    
    import "fmt"
    
    func main() {
    //make([]T, len, cap)创建切片 其中cap可以省略，则和len的值相同 len表示已存放的元素个数，cap表示容量,即最多可以存放的元素个数
    s1 := make([]int, 3)
    fmt.Println(s1)
    fmt.Println(len(s1))
    fmt.Println(cap(s1))
    }

输出：

[0 0 0]
      3
      3

package main
    
    import "fmt"
    
    func main() {
    s1 := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'}
    fmt.Println(s1)
    fmt.Println(s1[2:])
    fmt.Println(string(s1[2:4]))
    fmt.Println("加上string()后输出字符串，而不是输出ASCII码：" + string(s1[2]))
    }

输出：

[97 98 99 100 101 102 103 104 105 106 107]
      [99 100 101 102 103 104 105 106 107]
      cd
      加上string()后输出字符串，而不是输出ASCII码：c

package main
    
    import "fmt"
    
    func main() {
    s1 := []byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'}
    sa := string(s1[2:5])
    sb := string(sa[1:3]) //Reslice时索引以被slice的切片为准
    // sb := string(sa[1:4]) //索引不可以超过被slice的切片的容量cap()值 索引越界不会导致底层数组的重新分配而是引发错误
    fmt.Println(sa)
    fmt.Println(sb)
    }

输出;

cde
      de

append函数的使用

package main
    
    import "fmt"
    
    func main() {
    s1 := make([]int, 3, 6)
    fmt.Printf("%p\n", s1) //打印内存地址
    s1 = append(s1, 1, 2, 3)
    fmt.Printf("%v %p\n", s1, s1) //打印内存地址
    s2 := append(s1, 1, 2, 3) //当添加元素超出最大的容量时，重新分配内存地址，把数据拷贝过去以后，再追加元素，则切片的地址就会发生变化了
    fmt.Printf("%v %p\n", s2, s2) //打印内存地址，此时的地址与前面的不同
    }

输出：

0xc042064030
      [0 0 0 1 2 3] 0xc042064030
      [0 0 0 1 2 3 1 2 3] 0xc04203a0c0

package main
    
    import "fmt"
    
    func main() {
    a := []int{1, 2, 3, 4, 5}
    s1 := a[2:5]
    s2 := a[1:3]
    fmt.Println(s1) //3是s1和s2共同的部分，也就是说他们有指向相同的地址
    fmt.Println(s2)
    s2 = append(s2, 11, 12, 13, 1, 3, 4, 5, 6, 6, 7) //当append的时候，元素个数超出容量时，此时切片就会指向新的底层数组，而不再指向原来的数组a，而s1还是指向数组a，所以s1怎么变就不会影响s2了，这也是使用append时要注意的地方
    s1[0] = 22 //当某一个切片对相同的地址的值改变时，则另外切片对应的值也会相应改变
    fmt.Println(s1)
    fmt.Println(s2)
    }

输出：

[3 4 5]
      [2 3]
      [22 4 5]
      [2 3 11 12 13 1 3 4 5 6 6 7]

copy函数的使用（以短的切片为参照物）

长切片拷贝到短切片

package main
    
    import "fmt"
    
    func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := []int{11, 12, 13, 14, 15, 16, 17, 18, 19}
    copy(s1, s2)
    fmt.Println(s1)
    fmt.Println(s2)

输出：

[11 12 13 14 15]
    [11 12 13 14 15 16 17 18 19]

短切片拷贝到长切片

package main
    
    import "fmt"
    
    func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := []int{11, 12, 13, 14, 15, 16, 17, 18, 19}
    copy(s2, s1)
    fmt.Println(s2)
    fmt.Println(s1)
    }

输出：

[1 2 3 4 5 16 17 18 19]
      [1 2 3 4 5]

如何把一个切片转换给另外一个切片？

package main
    
    import "fmt"
    
    func main() {
    s1 := []int{1, 2, 3, 4, 5}
    // s2 := s1[:]
    // s2 := s1
    s2 := s1[:len(s1)]
    fmt.Println(s2)
    }

输出：

[1 2 3 4 5]