Go语言笔记--切片

最新推荐文章于 2022-10-20 22:37:08 发布
最新推荐文章于 2022-10-20 22:37:08 发布
阅读量326 收藏
点赞数
分类专栏： go Go语言学习笔记 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kongshuai19900505/article/details/88524376
版权

1.说明

1）其本身并不是数组，它指向底层的数组

2）作为变长数组的替代方案，可以关联底层数组的局部或全部

3）为引用类型

4）可以直接创建或从底层数组获取生成

5）使用len()获取元素个数，cap()获取容量

6）一般使用make()创建

7）如果多个slice指向相同底层数组，其中一个的值改变会影响全部

8）切片本身没有数据，是对数组底层的一个view

 

2.创建：

make([]T, len, cap)

其中cap可以省略，则容量和len的值相同

len表示存数的元素个数，cap表示容量

代码实例：直接var s []int形式

package main


import "fmt"


func main() {
    var s []int //没有元素则切片是空的
    for i := 0; i < 100; i++ {
        s = append(s, i)
    }
    fmt.Println(s)
}
输出：
API server listening at: 127.0.0.1:33537
[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]

使用make创建：

package main


import "fmt"


func main() {
    s := make([]int, 10)
    for i := 0; i < 10; i++ {
        s[i] = i
    }
    fmt.Println(s)
}
输出：
API server listening at: 127.0.0.1:21778
[0 1 2 3 4 5 6 7 8 9]

 

3.方法

1）Reslice

Reslice时所有以呗slice的切片为准

所有不可以超过呗slice的切片的容量cap()值

索引越界不会导致底层数组的重新分配而是引发错误

2）Append

可以在slice尾部追加元素

可以将一个slice追加在另一个slice尾部

如果最终长度为超过主机到slice的容量则返回原始slice

如果超过追加道德slice 的容量则将重新分配数组并拷贝原始数据

3）Copy

4.代码实例

package main


import "fmt"


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("arr[2:6]:", arr[2:6])
    fmt.Println("arr[:6]:", arr[:6])
    fmt.Println("arr[2:]:", arr[2:])
    fmt.Println("arr[:]:", arr[:])
}


输出：
API server listening at: 127.0.0.1:37693
arr[2:6]: [2 3 4 5]
arr[:6]: [0 1 2 3 4 5]
arr[2:]: [2 3 4 5 6 7 8 9]
arr[:]: [0 1 2 3 4 5 6 7 8 9]

上述代码中：

arr[2:6]从数组中取值是第2号元素到第5号元素，不包括6号

arr[:6]从头到第5号元素，不包括6号

arr[2:]从2号元素到结尾，包括2号元素

arr[:]获取所有元素

实例二

package main


import "fmt"


//参数中数组不加长度，这个就是切片
func updateSlice(s []int) {
    s[0] = 999
}


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s1 := arr[2:]
    fmt.Println("s1:", s1)
    s2 := arr[:]
    fmt.Println("s2:", s2)
    fmt.Println("after updateSlice(s1)")
    updateSlice(s1)
    fmt.Println(s1)
    fmt.Println(arr)


    fmt.Println("after updateSlice(s2)")
    updateSlice(s2)
    fmt.Println(s2)
    fmt.Println(arr)
}

API server listening at: 127.0.0.1:19977
s1: [2 3 4 5 6 7 8 9]
s2: [0 1 2 3 4 5 6 7 8 9]
after updateSlice(s1)
[999 3 4 5 6 7 8 9]
[0 1 999 3 4 5 6 7 8 9]
after updateSlice(s2)
[999 1 999 3 4 5 6 7 8 9]
[999 1 999 3 4 5 6 7 8 9]

这段代码中updateSlice完成了对数组的数据更新

切片还有一种操作叫做reslice

package main


import "fmt"


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    s := arr[:]
    fmt.Println(s)
    s = s[:5]
    fmt.Println(s)
    s = s[2:]
    fmt.Println(s)
}
输出：
API server listening at: 127.0.0.1:3798
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4]
[2 3 4]

5.扩展

1)实例说明

看下面一段代码执行结果是多少：

package main


import "fmt"


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6
    fmt.Println(s1)
    s2 := s1[3:5]
    fmt.Println(s2)
}

输出：
API server listening at: 127.0.0.1:43832
[2 3 4 5]
[5 6]

上述代码S的值是2，3，4，5但是s2是s1的切片，为什么取值不是s1里面的内容呢，显然5和6已经超出了范围。请看下图：

有底层数组向上一次是数组arr的内容是0,1,2,3,4,5,6,7那么s1作为arr的切片取值下标是2--6也就是说:

s1[0] = 2

s1[1] = 3

s1[2] = 4

s1[3] = 5

s1[4] = 6

s1[5] = 7

s2是s1的切片，取值是s1的3--5下标，对应到数组arr里面就是arr[5]--arr[6]两个元素

所以s2的元素值就是：

s2[0] = 5

s2[1] = 6

s2[2] = 7

2）底层实现

如下图所示slice内部三个元素

切片扩展有两个规则：

1）slice可以向后扩展，不可以向前扩展

2）s[i]不可以超越len(s),向后扩展不可以超越底层数组cap(s)

package main


import "fmt"


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]
    fmt.Println(s1)
    fmt.Println(len(s1))
    fmt.Println(cap(s1))
    s2 := s1[3:5]
    fmt.Println(s2)
    fmt.Println(len(s2))
    fmt.Println(cap(s2))
}

输出：
API server listening at: 127.0.0.1:21562
[2 3 4 5]
4
6
[5 6]
2
3

6.向切片增加元素

规则：

1）添加元素时如果超越cap，系统会重新分配更大的底层数组

2）由于值传递的关系，必须接收append的返回值（原因就是因为可能超越cap，这时分配的是新的底层数组）

看下面一段代码，通过append向切片内部增加元素

package main


import "fmt"


func main() {
    arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := arr[2:6]
    fmt.Println("s1 = ", s1)
    s2 := s1[3:5]
    fmt.Println("s2 = ", s2)
    s3 := append(s2, 10)
    s4 := append(s3, 11)
    s5 := append(s4, 12)
    fmt.Println("s3, s4, s5 = ", s3, s4, s5)
    fmt.Println("arr = ", arr)
}
输出：
API server listening at: 127.0.0.1:18118
s1 =  [2 3 4 5]
s2 =  [5 6]
s3, s4, s5 =  [5 6 10] [5 6 10 11] [5 6 10 11 12]
arr =  [0 1 2 3 4 5 6 10]

上述代码显示s4和s5已经超越了arr所以这哥底层数组已经不是之前的arr了是一个新的arr

下面代码通过打印len和cap观察切片的长度和容量是如何扩展增加的，cap是倍数扩展的

package main


import "fmt"


func printSlice(s []int) {
    fmt.Println("len(s) =  cap(s) = ", len(s), cap(s))
}


func main() {
    var s []int //没有元素则切片是空的，不会崩溃
    for i := 0; i < 10; i++ {
        printSlice(s)
        s = append(s, i)
    }
    fmt.Println(s)
}

输出：
API server listening at: 127.0.0.1:25704
len(s) =  cap(s) =  0 0
len(s) =  cap(s) =  1 1
len(s) =  cap(s) =  2 2
len(s) =  cap(s) =  3 4
len(s) =  cap(s) =  4 4
len(s) =  cap(s) =  5 8
len(s) =  cap(s) =  6 8
len(s) =  cap(s) =  7 8
len(s) =  cap(s) =  8 8
len(s) =  cap(s) =  9 16
[0 1 2 3 4 5 6 7 8 9]

7.拷贝删除操作

package main


import "fmt"


func main() {
    s1 := []int{2, 4, 6, 8}
    fmt.Println("s1 = ", s1)
    s2 := make([]int, 16)
    fmt.Println("s2 = ", s2)
    copy(s2, s1) //拷贝s1到s2
    fmt.Println("s2 = ", s2)
    s2 = append(s2[:3], s2[4:]...) //删除8
    fmt.Println("s2 = ", s2)       //打印出来可以看到8这个元素被删除了整个切片的长度小了一个
    //删除头元素操作
    front := s2[0] //取出来查看头元素
    s2 = s2[1:]    //删除头元素
    fmt.Println("front = ", front)
    fmt.Println("s2 = ", s2)
    //删除尾元素操作
    tail := s2[len(s2)-1] //取出来查看尾元素
    s2 = s2[:len(s2)-1]   //删除尾元素
    fmt.Println("tail = ", tail)
    fmt.Println("s2 = ", s2)
}
输出：
API server listening at: 127.0.0.1:47314
s1 =  [2 4 6 8]
s2 =  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
s2 =  [2 4 6 8 0 0 0 0 0 0 0 0 0 0 0 0]
s2 =  [2 4 6 0 0 0 0 0 0 0 0 0 0 0 0]
front =  2
s2 =  [4 6 0 0 0 0 0 0 0 0 0 0 0 0]
tail =  0
s2 =  [4 6 0 0 0 0 0 0 0 0 0 0 0]

练习实例：

    s1 := []int{2, 4, 6, 8} //初始化
	fmt.Println("s1 = ", s1)
	s2 := make([]int, 16) //申请一个空的，默认初始化值都是0
	fmt.Println("s2 = ", s2)
	copy(s2, s1) //拷贝s1到s2
	fmt.Println("s2 = ", s2)
	s2 = append(s2[:3], s2[4:]...) //删除8
	fmt.Println("s2 = ", s2)       //打印出来可以看到8这个元素被删除了整个切片的长度小了一个
	//删除头元素操作
	front := s2[0] //取出来查看头元素
	s2 = s2[1:]    //删除头元素
	fmt.Println("front = ", front)
	fmt.Println("s2 = ", s2)
	//删除尾元素操作
	tail := s2[len(s2)-1] //取出来查看尾元素
	s2 = s2[:len(s2)-1]   //删除尾元素
	fmt.Println("tail = ", tail)
	fmt.Println("s2 = ", s2)

输出：

s1 =  [2 4 6 8]
s2 =  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
s2 =  [2 4 6 8 0 0 0 0 0 0 0 0 0 0 0 0]
s2 =  [2 4 6 0 0 0 0 0 0 0 0 0 0 0 0]
front =  2
s2 =  [4 6 0 0 0 0 0 0 0 0 0 0 0 0]
tail =  0
s2 =  [4 6 0 0 0 0 0 0 0 0 0 0 0]

 

kongslly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go 切片详解
sh282404472的博客
11-24 743
实现原理 go中的切片是顺序性的变长容器。底层的用数组存储数据，当添加数据到达数组容量最大值后，重新分配一个更大的数组，并把原来的数据复制到新的数组中，最后再添加新的数据到末尾。 其结构体表示为： type slice struct { array unsafe.Pointer len int cap int } 切片的切取 切取切片有2种方式 s[start:end] s[start:end:max] start表示起始下标，end表示结束下标，但是不包括该...
剑指offer-题目-思路-python实现51-60
霜叶的博客
08-10 258
51.构建乘积数组 给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素 B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。 先求前向乘积列表t_forword=a[0]*a[1]*...*a[i-1];存入b 再求后项乘积列表t_back=a[len(a)-1]*a[len(a)-1]*...*a[i+1];b[i]*t_back得到最后结果 class Solution: def mult
golang slice len(s) vs cap(s)详解
企鹅菜鸟的成长过程
12-11 1147
len规则：s[x:y], len为 y-x 的值。 cap规则：一个切片的容量可以被看做是透过这个窗口最多可以看到的底层数据中元素的个数，在底层数组不变的情况下，切片代表的窗口可以向右扩展，纸质底层数组的末尾。 即在底层数组中剩余的元素个数 The start and end indices of a slice expression are optional; they default to zero and the slice's length https://blog.golang.org
Go语言学习14-内建函数
Huazie
04-07 972
Go语言数据的使用之内建函数
JavaScript 数组拼接打印_【JavaScript】Array数组常规使用小结(持续更新......)
weixin_40002336的博客
11-20 188
一、概述JavaScript的Array对象是用于构造数组的全局对象，数组是类似于列表的高阶对象。二、创建数组四种方式2.1、字面-隐式创建数组varmovieList=["大圣归来","哪吒之魔童降世","八佰"];console.log(movieList.length);// 3// 数组直接量还可以包含对象直接量和其他数组直接量var complexArr =[1, ...
go 语言学习笔记⑥----切片
qq_52410477的博客
01-11 291
文章目录go 语言学习笔记⑥----切片声明函数切片与数组区别make函数截取append函数copy做函数参数 go 语言学习笔记⑥----切片 通过内部指针和相关属性，引用数组片段，以实现变长方案。 go中数据结构， 我们可以增加更多的值 声明 arr := [...]int{1, 2, 3, 4, 5, 6} slice := arr[0:3:5] **数组[起始位置：终止位置：max] **（左闭右开） 长度= 终止 - 起始 容量= max - 起始 函数 len()长度 cap()容量 arr
Go语言学习笔记----切片
suoyudong的博客
03-21 221
切片—动态分配大小的连续空间 Go语言切片内部结构包含地址、大小和容量。切片一般用于快速地操作一块数据集合。
Go学习笔记 -- 数组和切片
最新发布
zhangdm的博客
10-20 504
Go 数组和切片
go学习笔记-文档-文档
07-21
Go语言，又称Golang，是Google在2009年推出的开源编程语言，设计初衷是为了提高软件开发的效率，提供简单、高效的编程体验。本文档集合了关于Go语言的学习笔记，旨在帮助读者全面理解并掌握Go语言的核心概念、语法...
韩顺平_Go语言核心编程完整版笔记.zip
08-22
《韩顺平Go语言核心编程完整版笔记》是一份全面且深入的学习资料，旨在帮助学习者掌握Go语言的核心概念和编程技巧。这份笔记基于韩顺平老师的Go语言视频教程，内容丰富，覆盖了Go语言的各个方面，对于想要系统学习Go...
Go语言学习笔记05--切片slice与字典map
FengziTianYu的专栏
11-25 2786
1.数组案例 //统计输入20个字符中字母出现的个数案例 func checkNumFromInput(){     inputCharArr := [20]byte{},checkNum := [26]byte{}     //输入     for i:=0; i&lt;20; i++{         fmt.Scanf("%c",&amp;inputCharArr[i]);     }   ...
Go语言笔记---反射学习
suoyudong的博客
04-18 147
文章目录反射反射的类型对象反射的值对象 反射 反射是指程序运行期对程序本身进行访问和修改的能力。 程序在编译时，变量被转换位内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取本身的信息。 支持反射的语言可以在程序编译期将变量的反射信息，如字段信息、类型信息、结构体信息等整合到可执行文件中去，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改...
《Go语言学习笔记》 - 第五章 - 切片
来自东印度的人
05-07 361
3. 切片 3.1 切片的概念 Go语言中切片是对数组的抽象，切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。 3.2 切片的操作 3.2.1 切片的创建 切片的创建与数组有所不同，切片是引用类型，它的创建需要用到内置函数 make ，函数make 接受一个类型、一个长度和一个可选的容量参数。调用 make 时，内部会分配一个数组，...
golang获取UUID
kslly的专栏
01-17 2484
package main import ( "fmt" uuid "github.com/satori/go.uuid" ) func main() { // 创建 u1 := uuid.NewV4() fmt.Printf("UUIDv4: %s\n", u1) // 解析 u2, err := uuid.FromString("f5394eef-e576-4709-9e...
Go语言笔记--数组
kslly的专栏
03-08 1392
1.数组Array 1）定义数组的格式：var &lt;varName&gt; [n] &lt;type&gt;, n &gt;=0 2）数组长度也是类型的一部分，因此具有不同长度的数组为不同类型 3）注意区分指向数组的指针和指针数组 4）数组在Go中为数值类型 5）数组直接可以使用==或者!=进行比较，但是不可以使用&lt;或者&gt; 6）可以使用new来创建数组，此方法返回一个指...
GO语言笔记--接口
kslly的专栏
05-01 1312
1.接口interface 1）接口是一个或多个方法签名的集合 2）只要某个类型拥有该接口的所有方法签名，即算实现该接口无需显示声明实现了哪个接口，这称为Structural Typing 3）接口只有方法声明，没有实现，没有数据字段 4）接口可以匿名嵌入其他接口，或嵌入到结构中 5）将对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获...
GO语言笔记--函数
kslly的专栏
04-21 587
1.函数function 1）Go函数不支持嵌套、重载和默认参数 2）但支持以下特性：无需声明原型、不定长参数、多返回值、命名返回值参数、匿名函数、闭包 3）定义函数只有关键字func，且左大括号不能另起一行 4）函数也可以作为一种类型使用 5）函数可以返回多个值 2.defer 1）执行方式类似其他语言中的析构函数，在函数执行结束后安装调用顺序的相反顺序逐个执行 2）即使函数发生...
Go语言笔记--基础（一）
kslly的专栏
02-19 511
1.定义 Go是一门并发支持/垃圾回收的编译型系统编程语言，旨在创造一门具有在静态编译语言的高性能和动态语言的高并发之间拥有良好平衡点的一门编程语言。 2.特点 1）类型安全和内存安全 2）以非常直观和极低代价的方案实现高并发 3）高效的垃圾回收机制 4）快速编译（同时解决C语言中头文件太多的问题） 5）为多核计算机提供性能提升的方案 6）UTF-8编码支持 3.Go环境变...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值