怎么使用Go语言的copy()实现切片复制

其他教程   发布日期:2024年11月13日   浏览次数:218

本文小编为大家详细介绍“怎么使用Go语言的copy()实现切片复制”,内容详细,步骤清晰,细节处理妥当,希望这篇“怎么使用Go语言的copy()实现切片复制”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。

Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中,如果加入的两个数组切片不一样大,就会按照其中较小的那个数组切片的元素个数进行复制。

copy() 函数的使用格式如下:

  1. copy( destSlice, srcSlice []T) int

其中 srcSlice 为数据来源切片,destSlice 为复制的目标(也就是将 srcSlice 复制到 destSlice),目标切片必须分配过空间且足够承载复制的元素个数,并且来源和目标的类型必须一致,copy() 函数的返回值表示实际发生复制的元素个数。

下面的代码展示了使用 copy() 函数将一个切片复制到另一个切片的过程:

  1. slice1 := []int{1, 2, 3, 4, 5}
  2. slice2 := []int{5, 4, 3}
  3. copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
  4. copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

虽然通过循环复制切片元素更直接,不过内置的 copy() 函数使用起来更加方便,copy() 函数的第一个参数是要复制的目标 slice,第二个参数是源 slice,两个 slice 可以共享同一个底层数组,甚至有重叠也没有问题。

【示例】通过代码演示对切片的引用和复制操作后对切片元素的影响。

  1. package main
  2. import "fmt"
  3. func main() {
  4. // 设置元素数量为1000
  5. const elementCount = 1000
  6. // 预分配足够多的元素切片
  7. srcData := make([]int, elementCount)
  8. // 将切片赋值
  9. for i := 0; i < elementCount; i++ {
  10. srcData[i] = i
  11. }
  12. // 引用切片数据
  13. refData := srcData
  14. // 预分配足够多的元素切片
  15. copyData := make([]int, elementCount)
  16. // 将数据复制到新的切片空间中
  17. copy(copyData, srcData)
  18. // 修改原始数据的第一个元素
  19. srcData[0] = 999
  20. // 打印引用切片的第一个元素
  21. fmt.Println(refData[0])
  22. // 打印复制切片的第一个和最后一个元素
  23. fmt.Println(copyData[0], copyData[elementCount-1])
  24. // 复制原始数据从4到6(不包含)
  25. copy(copyData, srcData[4:6])
  26. for i := 0; i < 5; i++ {
  27. fmt.Printf("%d ", copyData[i])
  28. }
  29. }

代码说明如下:

  • 第 8 行,定义元素总量为 1000。

  • 第 11 行,预分配拥有 1000 个元素的整型切片,这个切片将作为原始数据。

  • 第 14~16 行,将 srcData 填充 0~999 的整型值。

  • 第 19 行,将 refData 引用 srcData,切片不会因为等号操作进行元素的复制。

  • 第 22 行,预分配与 srcData 等大(大小相等)、同类型的切片 copyData。

  • 第 24 行,使用 copy() 函数将原始数据复制到 copyData 切片空间中。

  • 第 27 行,修改原始数据的第一个元素为 999。

  • 第 30 行,引用数据的第一个元素将会发生变化。

  • 第 33 行,打印复制数据的首位数据,由于数据是复制的,因此不会发生变化。

  • 第 36 行,将 srcData 的局部数据复制到 copyData 中。

  • 第 38~40 行,打印复制局部数据后的 copyData 元素。

补:从切片中删除元素

  1. package main
  2. import "fmt"
  3. //Go语言并没有对删除切片元素提供专用的语法或者接口,需要使用切片本身的特性来删除元素,
  4. //Go语言中删除切片元素的本质是,以被删除元素为分界点,将前后两个部分的内存重新连接起来。
  5. // 根据要删除元素的位置有三种情况,分别是从开头位置删除、从中间位置删除和从尾部删除,其中删除切片尾部的元素速度最快。
  6. func main() {
  7. //用=号的话必须先var声明
  8. var a [] int
  9. a=[]int{4,5,6}
  10. fmt.Println(a) //[4 5 6]
  11. //用:=是声明并赋值,并且系统自动判断类型,不需要var关键字
  12. b:=[]int{7,8,9}
  13. fmt.Println(b) //[7 8 9]
  14. //1.利用切片的特性来删除元素
  15. a=a[1:] //取索引1以后的值(包含索引1)即删除a[0]
  16. //a=a[N:] //删除开头n个元素
  17. fmt.Println(a) //[5 6]
  18. //2.也可以不移动数据指针,但是将后面的数据向开头移动,可以用 append 原地完成
  19. // 所谓原地完成是指在原有的切片数据对应的内存区间内完成,不会导致内存空间结构的变化:
  20. fmt.Println(a[:0]) //取到a[0]结尾且不包含a[0],即为[]
  21. a = append(a[:0],a[1:]...)//在尾部追加a[1:],即a[n:]删除前n个元素
  22. fmt.Println(a) //[6]
  23. //3.copy()函数删除元素
  24. //copy把b[1:]复制给b,返回复制后的len(b),多此一举,和b[1:]结果一样
  25. b=b[:copy(b,b[1:])]
  26. fmt.Println(b) //[8 9]
  27. //4.从中间位置删除
  28. //对于删除中间的元素,需要对剩余的元素进行一次整体挪动,同样可以用append或copy原地完成
  29. //append操作
  30. c:=[]int{1,2,3,4,5}
  31. //c=append(c[:i],c[i+1:]...) 删除中间一个元素:(c[i])
  32. //c=append(c[:i],c[i+N:]...) 删除中间N个元素:(c[i:I+N-1])
  33. //先取c[:1]之前的数据,在追加c[2:]之后的数据,即删除c[1]
  34. c=append(c[:1],c[2:]...)
  35. fmt.Println(c) //[1 3 4 5]
  36. //copy操作
  37. d:=[]int{1,2,3,4,5}
  38. //d=d[:i+copy(d[i:],d[i+1:])] 删除中间一个元素(d[i]),因为从d[i:]开始的,所以i是之前元素的个数
  39. //d=d[:i+copy(d[i:],d[i+N:])] 删除中间N个元素
  40. //先将d[2:]之后的数据copy给d[1:]之后的数据,即删除了d[1]数据,并返回len(d[2:]),再连接d[1]之前的数据
  41. d=d[:1+copy(d[1:],d[2:])] //删除中间一个元素(d[1])
  42. fmt.Println(d)//[1 3 4 5]
  43. //5.从尾部删除
  44. g:=[]int{1,2,3,4}
  45. g=g[:len(g)-1] //删除尾部一个元素
  46. //g=g[:len(g)-N] //删除尾部N个元素
  47. fmt.Println(g) //[1 2 3]
  48. index()
  49. }
  50. //删除切片指定位置的元素
  51. func index() {
  52. str:=[]string{"a","b","c","d"}
  53. //指定删除索引
  54. index:=2
  55. //查看删除索引之前的元素,删除索引之后的元素
  56. fmt.Println(str[:index],str[index+1:]) //[a b] [d]
  57. //将删除点前后元素连接起来
  58. str=append(str[:index],str[index+1:]...)
  59. fmt.Println(str) //[a b d]

以上就是怎么使用Go语言的copy()实现切片复制的详细内容,更多关于怎么使用Go语言的copy()实现切片复制的资料请关注九品源码其它相关文章!