Go语言切片详解

最新推荐文章于 2023-08-01 17:45:54 发布

!一直往南方开.

最新推荐文章于 2023-08-01 17:45:54 发布

阅读量499

点赞数 1

分类专栏： Go语言

本文链接：https://blog.csdn.net/qq_44205272/article/details/104407840

版权

Go语言专栏收录该内容

11 篇文章 2 订阅

订阅专栏

Go语言切片详解

从数组或切片生成新的切片

切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。

从连续内存区域生成切片是常见的操作，格式如下：

slice [开始位置 : 结束位置]

从数组生成切片，代码如下：
var a = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])

结果如下：
[1 2 3] [2]

从指定范围中生成切片

var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])

代码输出如下：
[11 12 13 14 15]
[21 22 23 24 25 26 27 28 29 30]
[1 2]

代码中构建了一个 30 层的高层建筑，数组的元素值从 1 到 30，分别代表不同的独立楼层，输出的结果是不同的租售方案。

表示原有的切片

生成切片的格式中，当开始和结束位置都被忽略时，生成的切片将表示和原切片一致的切片，并且生成的切片与原切片在数据内容上也是一致的，代码如下：
a := []int{1, 2, 3}
fmt.Println(a[:])
输出如下：
[1 2 3]

重置切片，清空拥有的元素

把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：
a := []int{1, 2, 3}
fmt.Println(a[0:0])
代码输出如下：
[]

切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。

使用 make() 函数构造切片

如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：
make( []Type, size, cap )

其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

示例如下：
a := make([]int, 2)
b := make([]int, 2, 10)
fmt.Println(a, b)
fmt.Println(len(a), len(b))

代码输出如下：
[0 0] [0 0]
2 2

其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。

使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

内建函数 append() 可以为切片动态添加元素

var a []int
a = append(a, 1) // 追加1个元素
a = append(a, 1, 2, 3) // 追加多个元素, 手写解包方式
a = append(a, []int{1,2,3}…) // 追加一个切片, 切片需要解包

不过需要注意的是，在使用 append() 函数为切片动态添加元素时，如果空间不足以容纳足够多的元素，切片就会进行“扩容”，此时新切片的长度会发生改变。

切片在扩容时，容量的扩展规律是按容量的 2 倍数进行扩充，例如 1、2、4、8、16……，代码如下：

var numbers []int
for i := 0; i < 10; i++ {
    numbers = append(numbers, i)
    fmt.Printf("len: %d  cap: %d pointer: %p\n", len(numbers), cap(numbers), numbers)
}

代码输出如下：
len: 1 cap: 1 pointer: 0xc0420080e8
len: 2 cap: 2 pointer: 0xc042008150
len: 3 cap: 4 pointer: 0xc04200e320
len: 4 cap: 4 pointer: 0xc04200e320
len: 5 cap: 8 pointer: 0xc04200c200
len: 6 cap: 8 pointer: 0xc04200c200
len: 7 cap: 8 pointer: 0xc04200c200
len: 8 cap: 8 pointer: 0xc04200c200
len: 9 cap: 16 pointer: 0xc042074000
len: 10 cap: 16 pointer: 0xc042074000

通过查看代码输出，可以发现一个有意思的规律：切片长度 len 并不等于切片的容量 cap。

因为 append 函数返回新切片的特性，所以切片也支持链式操作，我们可以将多个 append 操作组合起来，实现在切片中间插入元素：

var a []int
a = append(a[:i], append([]int{x}, a[i:]...)...) // 在第i个位置插入x
a = append(a[:i], append([]int{1,2,3}, a[i:]...)...) // 在第i个位置插入切片

每个添加操作中的第二个 append 调用都会创建一个临时切片，并将 a[i:] 的内容复制到新创建的切片中，然后将临时创建的切片再追加到 a[:i] 中

在这里插入图片描述

package main

import "fmt"

func main() {
	// 数组
	var arr = [4] int{1,2,3,4}
	fmt.Println(arr)

	// 切片
	var s = [] int{1,2,3,4}
	fmt.Println(s)

	// func make()函数
	/*
	第一个参数 类型（slice,map,chan）
	第二个参数 长度len
	第三个参数 容量cap
	*/
	s1 := make([]int, 3, 8)
	fmt.Println(s1)
	fmt.Println(len(s1), cap(s1))

	// append()
	// 超过容量会自动扩容
	s1 = append(s1, 1,2,3)
	fmt.Println(s1)
	// 切片作为参数添加
	s1 = append(s1, s...)
	fmt.Println(s1)
	fmt.Println(s1[2:6])

	var a = [10] int{1,2,3,4,5,6,7,8,9,10}
	v1 := a[1:4]
	v2 := a[3:]
	v3 := a[:7]
	v4 := a[:]
	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
	fmt.Printf("%p\n",&a)
	fmt.Printf("%p\n",&v1)
	fmt.Printf("%p\n",&v2)
	fmt.Printf("%p\n",&v3)
	fmt.Printf("%p\n",&v4)
	fmt.Println("**************")
	a[5] = 100
	fmt.Println(a)
	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
	fmt.Printf("%p\n",&a)
	fmt.Printf("%p\n",&v1)
	fmt.Printf("%p\n",&v2)
	fmt.Printf("%p\n",&v3)
	fmt.Printf("%p\n",&v4)
	fmt.Println("**************")
	v4[7] = 999
	fmt.Println(a)
	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
	fmt.Printf("%p\n",&a)
	fmt.Printf("%p\n",&v1)
	fmt.Printf("%p\n",&v2)
	fmt.Printf("%p\n",&v3)
	fmt.Printf("%p\n",&v4)
	fmt.Println("**************")
	v2 = append(v2, 0,0,0)
	fmt.Println(a)
	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
	fmt.Printf("%p\n",&a)
	fmt.Printf("%p\n",&v1)
	fmt.Printf("%p\n",&v2)
	fmt.Printf("%p\n",&v3)
	fmt.Printf("%p\n",&v4)
	fmt.Println("**************")
	v2 = append(v2, 0,0,0,0,0,0,0,0)
	fmt.Println(a)
	fmt.Println(v1)
	fmt.Println(v2)
	fmt.Println(v3)
	fmt.Println(v4)
	fmt.Printf("%p\n",&a)
	fmt.Printf("%p\n",&v1)
	fmt.Printf("%p\n",&v2)
	fmt.Printf("%p\n",&v3)
	fmt.Printf("%p\n",&v4)
}

[1 2 3 4]
[1 2 3 4]
[0 0 0]
3 8
[0 0 0 1 2 3]
[0 0 0 1 2 3 1 2 3 4]
[0 1 2 3]
[2 3 4]
[4 5 6 7 8 9 10]
[1 2 3 4 5 6 7]
[1 2 3 4 5 6 7 8 9 10]
0xc0000160f0
0xc000004560
0xc000004580
0xc0000045a0
0xc0000045c0
**************
[1 2 3 4 5 100 7 8 9 10]
[2 3 4]
[4 5 100 7 8 9 10]
[1 2 3 4 5 100 7]
[1 2 3 4 5 100 7 8 9 10]
0xc0000160f0
0xc000004560
0xc000004580
0xc0000045a0
0xc0000045c0
**************
[1 2 3 4 5 100 7 999 9 10]
[2 3 4]
[4 5 100 7 999 9 10]
[1 2 3 4 5 100 7]
[1 2 3 4 5 100 7 999 9 10]
0xc0000160f0
0xc000004560
0xc000004580
0xc0000045a0
0xc0000045c0
**************
[1 2 3 4 5 100 7 999 9 10]
[2 3 4]
[4 5 100 7 999 9 10 0 0 0]
[1 2 3 4 5 100 7]
[1 2 3 4 5 100 7 999 9 10]
0xc0000160f0
0xc000004560
0xc000004580
0xc0000045a0
0xc0000045c0
**************
[1 2 3 4 5 100 7 999 9 10]
[2 3 4]
[4 5 100 7 999 9 10 0 0 0 0 0 0 0 0 0 0 0]
[1 2 3 4 5 100 7]
[1 2 3 4 5 100 7 999 9 10]
0xc0000160f0
0xc000004560
0xc000004580
0xc0000045a0
0xc0000045c0

!一直往南方开.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Go语言切片详解

Go语言切片详解从数组或切片生成新的切片切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。从连续内存区域生成切片是常见的操作，格式如下：slice [开始位置 : 结束位置]从数组生成切片，代码如下：var a = [3]int{1, 2, 3}fmt.Println(a, a[1:2])结果如下：[1 2 3] [2]从指定范围中生成切片var highR...
复制链接

扫一扫