人生苦短我使用GO——GO切片

最新推荐文章于 2023-06-21 21:07:20 发布

小柏ぁ

最新推荐文章于 2023-06-21 21:07:20 发布

阅读量518

点赞数

分类专栏： GO语言文章标签： golang

本文链接：https://blog.csdn.net/weixin_48404074/article/details/123959258

版权

GO语言专栏收录该内容

21 篇文章 0 订阅

订阅专栏

用append内置函数操作切片（切片追加）

超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。

切片Slice

需要说明，slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。

可以说Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

    1. 切片：切片是数组的一个引用，因此切片是引用类型。但自身是结构体，值拷贝传递。
    2. 切片的长度可以改变，因此，切片是一个可变的数组。
    3. 切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制。 
    4. cap可以求出slice最大扩张容量，不能超出数组限制。0 <= len(slice) <= len(array)，其中array是slice引用的数组。
    5. 切片的定义：var 变量名 []类型，比如 var str []string  var arr []int。
    6. 如果 slice == nil，那么 len、cap 结果都等于 0。

创建切片的几种方式

package main

import "fmt"

func main() {
	//1、声明切片
	var s1 []int

	if s1 == nil {
		fmt.Println("切片为空")
	} else {
		fmt.Println("切片不为空")
	}

	//2、:=
	s2 := []int{}

	fmt.Println(s2)
	//3、make

	var s3 []int = make([]int, 3)

	fmt.Println(s3)
	// 4.初始化赋值

	var s4 []int = make([]int, 0, 0)

	fmt.Println(s4)

	s5 := []int{1, 2, 3}

	fmt.Println(s5)

	// 5.从数组切片

	arr := [5]int{1, 2, 3, 4, 5}

	// 6、前包后不包
	var s6 []int

	s6 = arr[1:4]

	fmt.Println(s6)
}

切片初始化

操作	含义
s[n]	切片s中索引位置为n的项
s[:]	从切片s 的索引位置0到len(s)-1处所获得的切片
s[low:]	从切片s的索引位置low到len(s)-1处所获得的切片
s[:high]	从切片s的索引位置0到 high 处所获得的切片，len=high
s[low:high]	从切片s的索引位置low到 high 处所获得的切片，len=high-low
s[low: high:max]	从切片s的索引位置low到high 处所获得的切片，len=high-low，cap=max-low
len(s)	切片s的长度，总是<=cap(s)
cap(s)	切片s的容量，总是>=len(s)

示例

package main

import "fmt"

var arr = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
var s0 []int = arr[2:8]
var s1 []int = arr[0:6] //可以简写为 [:end]
var s2 []int = arr[0:len(arr)] //var slice []int = arr[:]
var s3 []int = arr[:len(arr)-1] //去掉切片最后一个元素

func main() {

	fmt.Printf("全局变量:arr %v\n",arr)
	fmt.Printf("全局变量:s0 %v\n",s0)
	fmt.Printf("全局变量:s1 %v\n",s1)
	fmt.Printf("全局变量:s2 %v\n",s2)
	fmt.Printf("全局变量:s3 %v\n",s3)
	fmt.Println("---------------------------------")

	arr2 := [...]int{0,9,8,7,6,5,4,3,2,1}
	var s4 []int = arr2[2:8]
	var s5 []int = arr2[:6]
	var s6 []int = arr2[:len(arr2)]
	var s7 []int = arr2[:len(arr2)-1]

	fmt.Printf("局部变量:arr2 %v\n",arr2)
	fmt.Printf("局部变量:s4 %v\n",s4)
	fmt.Printf("局部变量:s5 %v\n",s5)
	fmt.Printf("局部变量:s6 %v\n",s6)
	fmt.Printf("局部变量:s7 %v\n",s7)


}

运行结果

全局变量:arr [1 2 3 4 5 6 7 8 9 0]
全局变量:s0 [3 4 5 6 7 8]
全局变量:s1 [1 2 3 4 5 6]
全局变量:s2 [1 2 3 4 5 6 7 8 9 0]
全局变量:s3 [1 2 3 4 5 6 7 8 9]
---------------------------------
局部变量:arr2 [0 9 8 7 6 5 4 3 2 1]
局部变量:s4 [8 7 6 5 4 3]
局部变量:s5 [0 9 8 7 6 5]
局部变量:s6 [0 9 8 7 6 5 4 3 2 1]
局部变量:s7 [0 9 8 7 6 5 4 3 2]

通过make创建切片

    var slice []type = make([]type, len)
    slice  := make([]type, len)
    slice  := make([]type, len, cap)

示例

package main

import (
	"fmt"
)

var slice0 []int = make([]int, 10)
var slice1 = make([]int, 10)
var slice2 = make([]int, 5, 10)

func main() {
	fmt.Printf("len=%d cap=%d slice0=%v\n", len(slice0), cap(slice0), slice0)
	fmt.Printf("len=%d cap=%d slice1=%v\n", len(slice1), cap(slice1), slice1)
	fmt.Printf("len=%d cap=%d slice2=%v\n", len(slice2), cap(slice2), slice2)
}

运行结果

len=10 cap=10 slice0=[0 0 0 0 0 0 0 0 0 0]
len=10 cap=10 slice1=[0 0 0 0 0 0 0 0 0 0]
len=5 cap=10 slice2=[0 0 0 0 0]

切片的内存布局

读写操作实际目标是底层数组，只需注意索引号的差别。

示例

package main

import (
    "fmt"
)

func main() {
    data := [...]int{0, 1, 2, 3, 4, 5}

    s := data[2:4]
    s[0] += 100
    s[1] += 200

    fmt.Println(s)
    fmt.Println(data)
}

运行结果

    [102 203]
    [0 1 102 203 4 5]

可直接创建 slice 对象，自动分配底层数组。

package main

import "fmt"

func main() {
    //8:是10元素的下标
    s1 := []int{0, 1, 2, 3, 8: 10} // 通过初始化表达式构造，可使用索引号。
    fmt.Println(s1, len(s1), cap(s1))

    s2 := make([]int, 6, 8) // 使用 make 创建，指定 len 和 cap 值。
    fmt.Println(s2, len(s2), cap(s2))

    s3 := make([]int, 6) // 省略 cap，相当于 cap = len。
    fmt.Println(s3, len(s3), cap(s3))
}

运行结果

[0 1 2 3 0 0 0 0 10] 9 9
[0 0 0 0 0 0] 6 8
[0 0 0 0 0 0] 6 6

使用 make 动态创建slice，避免了数组必须用常量做长度的麻烦。还可用指针直接访问底层数组，退化成普通数组操作。

package main

import "fmt"

func main() {

	s1 := []int {1,3,5,7}
	p := &s1[2]

	*p = 10
	fmt.Println(s1)
}

运行结果

[1 3 10 7]

用append内置函数操作切片（切片追加）

package main

import "fmt"

func main() {

	var a = []int{1, 2, 3}
	fmt.Printf("a切片=%d\n", a)
	var b = []int{4, 5, 6}
	fmt.Printf("b切片=%d\n", b)
	c := append(a, b...)
	fmt.Printf("追加之后的切片为:%d\n", c)
	d := append(c, 7)
	fmt.Printf("再追加%d\n", d)
	f := append(d, 8, 9, 10)
	fmt.Printf("f的切片 %v\n", f)
}

运行结果

a切片=[1 2 3]
b切片=[4 5 6]
追加之后的切片为:[1 2 3 4 5 6]
再追加[1 2 3 4 5 6 7]
f的切片 [1 2 3 4 5 6 7 8 9 10]

append ：向 slice 尾部添加数据，返回新的 slice 对象。

package main

import "fmt"

func main() {
	//append ：向 slice 尾部添加数据，返回新的 slice 对象。

	s1 := make([]int,0,8)
	fmt.Printf("%p\n",&s1)

	s2 := append(s1,6)
	fmt.Printf("%p\n",&s2)

	fmt.Println(s1,s2)
}

运行结果

0xc000004078
0xc000004090
[] [6]

超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。

示例

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 10: 0}
    s := data[:2:3]

    s = append(s, 66, 88) // 一次 append 两个值，超出 s.cap 限制。

    fmt.Println(s, data)         // 重新分配底层数组，与原数组无关。
    fmt.Println(&s[0], &data[0]) // 比对底层数组起始指针。

}

运行结果

[0 1 66 88] [0 1 2 3 4 0 0 0 0 0 0]
0xc00000c420 0xc00001a120

从输出结果可以看出，append 后的 s 重新分配了底层数组，并复制数据。如果只追加一个值，则不会超过 s.cap 限制，也就不会重新分配。通常以 2 倍容量重新分配底层数组。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。或初始化足够长的 len 属性，改用索引号进行操作。及时释放不再使用的 slice 对象，避免持有过期数组，造成 GC 无法回收。

切片拷贝

package main

import (
    "fmt"
)

func main() {

    s1 := []int{1, 2, 3, 4, 5}
    fmt.Printf("slice s1 : %v\n", s1)
    s2 := make([]int, 10)
    fmt.Printf("slice s2 : %v\n", s2)
    copy(s2, s1)
    fmt.Printf("copied slice s1 : %v\n", s1)
    fmt.Printf("copied slice s2 : %v\n", s2)
    s3 := []int{1, 2, 3}
    fmt.Printf("slice s3 : %v\n", s3)
    s3 = append(s3, s2...)
    fmt.Printf("appended slice s3 : %v\n", s3)
    s3 = append(s3, 4, 5, 6)
    fmt.Printf("last slice s3 : %v\n", s3)

}

运行结果

   slice s1 : [1 2 3 4 5]
    slice s2 : [0 0 0 0 0 0 0 0 0 0]
    copied slice s1 : [1 2 3 4 5]
    copied slice s2 : [1 2 3 4 5 0 0 0 0 0]
    slice s3 : [1 2 3]
    appended slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0]
    last slice s3 : [1 2 3 1 2 3 4 5 0 0 0 0 0 4 5 6]

copy ：函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。两个 slice 可指向同一底层数组，允许元素区间重叠。

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("array data : ", data)
    s1 := data[8:]
    s2 := data[:5]
    fmt.Printf("slice s1 : %v\n", s1)
    fmt.Printf("slice s2 : %v\n", s2)
    copy(s2, s1)
    fmt.Printf("copied slice s1 : %v\n", s1)
    fmt.Printf("copied slice s2 : %v\n", s2)
    fmt.Println("last array data : ", data)

}

运行结果

    array data :  [0 1 2 3 4 5 6 7 8 9]
    slice s1 : [8 9]
    slice s2 : [0 1 2 3 4]
    copied slice s1 : [8 9]
    copied slice s2 : [8 9 2 3 4]
    last array data :  [8 9 2 3 4 5 6 7 8 9]

切片遍历

package main

import (
    "fmt"
)

func main() {

    data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice := data[:]
    for index, value := range slice {
        fmt.Printf("inde : %v , value : %v\n", index, value)
    }

}

运行结果

    inde : 0 , value : 0
    inde : 1 , value : 1
    inde : 2 , value : 2
    inde : 3 , value : 3
    inde : 4 , value : 4
    inde : 5 , value : 5
    inde : 6 , value : 6
    inde : 7 , value : 7
    inde : 8 , value : 8
    inde : 9 , value : 9

字符串和切片

string底层就是一个byte的数组，因此，也可以进行切片操作。

package main

import (
    "fmt"
)

func main() {
    str := "hello world"
    s1 := str[0:5]
    fmt.Println(s1)

    s2 := str[6:]
    fmt.Println(s2)
}

输出结果：

    hello
    world

string本身是不可变的，因此要改变string中字符。需要如下操作：英文字符串：

package main

import (
    "fmt"
)

func main() {
    str := "Hello world"
    s := []byte(str) //中文字符需要用[]rune(str)
    s[6] = 'G'
    s = s[:8]
    s = append(s, '!')
    str = string(s)
    fmt.Println(str)
}

输出结果：

    Hello Go!

含有中文字符串：

package main

import (
    "fmt"
)

func main() {
    str := "你好，世界！hello world！"
    s := []rune(str) 
    s[3] = '晓'
    s[4] = '彬'
    s[12] = 'g'
    s = s[:14]
    str = string(s)
    fmt.Println(str)
}

输出结果：

你好，晓彬！hello go

golang slice data[:6:8] 两个冒号的理解

常规slice , data[6:8]，从第6位到第8位（返回6， 7），长度len为2，最大可扩充长度cap为4（6-9）

另一种写法： data[:6:8] 每个数字前都有个冒号， slice内容为data从0到第6位，长度len为6，最大扩充项cap设置为8

a[x:y:z] 切片内容 [x:y] 切片长度: y-x 切片容量:z-x

package main

import (
    "fmt"
)

func main() {
    slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    d1 := slice[6:8]
    fmt.Println(d1, len(d1), cap(d1))
    d2 := slice[:6:8]
    fmt.Println(d2, len(d2), cap(d2))
}

数组or切片转字符串：

    strings.Replace(strings.Trim(fmt.Sprint(array_or_slice), "[]"), " ", ",", -1)

小柏ぁ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
人生苦短我使用GO——GO切片

目录切片Slice创建切片的几种方式切片初始化通过make创建切片用append内置函数操作切片（切片追加）超出原 slice.cap 限制，就会重新分配底层数组，即便原数组并未填满。切片拷贝切片遍历字符串和切片含有中文字符串：...
复制链接

扫一扫