007.golang 切片slice

前端之家收集整理的这篇文章主要介绍了007.golang 切片slice前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

切片Slice

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

  • make([]T,len,cap)

    • 其中cap可以省略,则和len的值相同
    • len表示存数的元素个数,cap表示容量

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8. //空的slice
  9. var s1 []int
  10. fmt.Println(s1)
  11. //创建一个数组
  12. a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  13. fmt.Println(a)
  14. //获取索引从5到9的元素
  15. s2 := a[5:10] //包含开始索引,不包含结束索引
  16. fmt.Println(s2)
  17. //获取第七个以后所有的元素
  18. s3 := a[7:]
  19. fmt.Println(s3)
  20. //获取刚开始的前三个元素
  21. s4 := a[:3]
  22. fmt.Println(s4)
  23. //获取数组的所有元素 等价于 =
  24. s5 := a[:]
  25. s6 := a
  26. fmt.Println(s5)
  27. fmt.Println(s6)
  28. }


  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8. //表示此切片初始容量为3,
  9. //可以容纳为10
  10. //如果超过10就会自动扩容+10
  11. s1 := make([]int, 10)
  12. fmt.Println(s1)
  13. fmt.Println(len(s1),cap(s1))
  14.  
  15. a := []byte{'a','b','c','d','.','w','r','v','4','3','2'}
  16. s2 := a[2:4]
  17. fmt.Println(string(s2))
  18. }

Reslice

  • Reslice时索引以被slice的切片为准
  • 索引不可以超过被slice的切片的容量cap()值
  • 索引越界不会导致底层数组的重新分配而是引发错误
  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8.  
  9. a := []byte{'a','2'}
  10. s2 := a[2:4]
  11. s3 := s2[1:2]
  12. s4 := s2[1:8]
  13. fmt.Println(string(s2))
  14. fmt.Println(string(s3))
  15. fmt.Println(string(s4))
  16. }

Append

  • 可以在slice尾部追加元素
  • 可以将一个slice追加在另一个slice尾部
  • 如果最终长度未超过追加到slice的容量则返回原始slice
  • 如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据
  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8.  
  9. s1 := make([]int, 6)
  10. fmt.Printf("%p\n",s1)
  11. s1 = append(s1, 1, 3)
  12. fmt.Printf("%v %p\n",s1,s1)
  13. }

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8.  
  9. a := []int{1, 5}
  10. fmt.Println(a)
  11. //指向底层的数组
  12. s1 := a[2:5]
  13. s2 := a[1:3]
  14. s3 := a[1:3]
  15.  
  16. fmt.Println(s1,s2)
  17. //如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据
  18. s3 = append(s3, 1)
  19. //更改元素后,底层数组相应的也会更改
  20. s1[0] = 9
  21. fmt.Println(s1,s2)
  22. fmt.Println(s3)
  23. fmt.Println(a)
  24. }

Copy

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

  1. package main
  2.  
  3. import (
  4. "fmt"
  5. )
  6.  
  7. func main() {
  8.  
  9. s1 := []int{1, 10, 11}
  10.  
  11. copy(s2[2:4],s1[4:6])
  12. fmt.Println(s2)
  13. }

猜你在找的Go相关文章