Golang 切片(Slice)实现增删改查


Posted in Golang onApril 22, 2022

引言

Golang 的数组是固定长度,可以容纳相同数据类型的元素的集合。

但是当长度固定了,在使用的时候肯定是会带来一些限制,比如说:申请的长度太大会浪费内存,太小又不够用。

鉴于上述原因,我们有了 go 语言的切片,可以把切片理解为,可变长度的数组,其实它底层就是使用数组实现的,增加了自动扩容功能。

切片(Slice)是一个拥有相同类型元素的可变长度的序列。

一、切片的基础语法

1. 语法

声明一个切片和声明一个数组类似,只要不添加长度即可

var identifier []type

切片是引用类型,可以使用make函数来创建切片:

var slice1 []type =make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量,其中capacity为可选参数

make([]T,length,capacity)

这里len是数组的长度并且也是切片的初始长度

2. 示例

切片在没有赋值之前是空值

声明变量的方式创建切片

package main
 
import "fmt"
 
func main() {
    var names []string
    var numbers []int
    fmt.Printf("names: %v\n", names)
    fmt.Printf("numbers: %v\n", numbers)
    fmt.Println(names == nil)
    fmt.Println(numbers == nil)
}

输出结果如下

names: []
numbers: []
true
true

使用make函数创建切片

package main
 
import "fmt"
 
func main() {
    var a = make([]int, 2)
    var b = make([]int, 3)
 
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
}

输出结果如下

a: [0 0]
b: [0 0 0]

3. 切片的长度和容量

切片拥有自己的长度和容量,我们可以通过使用内置的len()函数求出长度,使用内置的cap()函数求出切片的内容。

package main
 
import "fmt"
 
func main() {
    var names = []string{"hello", "world"}
    var num = []int{1, 2, 3}
    fmt.Printf("len: %d cap: %d\n", len(names), cap(names))
    fmt.Printf("len: %d cap: %d\n", len(num), cap(num))
    fmt.Printf("num[2]: %v\n", num[2])//根据下标索引来获取切片的元素
    fmt.Println("-----------")
    var a = make([]string, 2, 3)
    fmt.Printf("len: %d cap: %d", len(a), cap(a))
}

输出结果如下

len: 2 cap: 2
len: 3 cap: 3
num[2]: 3
-----------
len: 2 cap: 3

二、切片的初始化

切片的初始化方式有很多种,可以直接初始化,也可以使用数组初始化。

1. 直接初始化

package main
 
import "fmt"
 
func main() {
    a := []int{1, 2, 3}
    fmt.Printf("a: %v\n", a)
}

输出结果如下

a: [1 2 3]

2. 使用数组初始化

package main
 
import "fmt"
 
func main() {
    a := [...]int{1, 2, 3}
    b := a[:]
    fmt.Printf("b: %v\n", b)
}

输出结果

b: [1 2 3]

3. 使用数组的部分元素初始化(切片表达式)

切片的底层就是一个数组,所以我们可以基于数组通过切片表达式得到切片。

切片表达式中的low和high表示一个索引范围(包左不包右),得到切片的长度=high-low,容量等于得到的切片的底层数组的容量。

package main
 
import "fmt"
 
func main() {
    a := [...]int{1, 2, 3, 4, 5, 6, 7, 8}
    b := a[2:5] //下标2到5,左闭右开,不包括5
    fmt.Printf("b: %v\n", b)
    c := a[2:] //下标2后面的所有
    fmt.Printf("c: %v\n", c)
    d := a[:3] //下标3之前的,不包括3
    fmt.Printf("d: %v\n", d)
    e := a[:] //取所有值
    fmt.Printf("e: %v\n", e)
}

输出结果如下

b: [3 4 5]
c: [3 4 5 6 7 8]
d: [1 2 3]
e: [1 2 3 4 5 6 7 8]

4. 空(nil)切片

一个切片在未初始化之前默认为nil,长度为0,容量为0

package main
 
import "fmt"
 
func main() {
    var a []int
    fmt.Println(a == nil)
    fmt.Printf("len: %d,cap: %d\n", len(a), cap(a))
}

输出结果如下

true
len: 0,cap: 0

三、切片的遍历

切片的遍历和数组的遍历非常类型,可以使用for循环索引遍历,或者for range循环

1. for 循环遍历

package main
 
import "fmt"
 
func main() {
    s1 := []int{1, 2, 3, 4, 5, 6}
    for i := 0; i < len(s1); i++ {
        fmt.Printf("s1[%d]: %v\n", i, s1[i])
    }
}

输出结果如下

s1[0]: 1
s1[1]: 2
s1[2]: 3
s1[3]: 4
s1[4]: 5
s1[5]: 6

2. for range遍历

package main
 
import "fmt"
 
func main() {
    s1 := []int{1, 2, 3, 4, 5, 6}
    for i, v := range s1 {
        fmt.Printf("i: %v,v: %v\n", i, v)
    }
}

输出结果如下,i是索引,v是值

i: 0,v: 1
i: 1,v: 2
i: 2,v: 3
i: 3,v: 4
i: 4,v: 5
i: 5,v: 6

四、切片元素的添加和删除copy

切片是一个动态数组,可以使用append()函数添加元素

go 语言中并没有删除切片元素的专用方法,我们可以使用切片本身的特性来删除元素。

由于切片是引用类型,通过赋值的方式,会修改原有内容,go 提供了copy()函数来拷贝切片

1. 添加元素

package main
 
import "fmt"
 
func main() {
    a := []int{}
    a = append(a, 1)
    a = append(a, 2)
    a = append(a, 3, 4, 5) //添加多个元素
    fmt.Printf("a: %v\n", a)
    fmt.Println("---------------------")
    a1 := []int{3, 4, 5}
    a2 := []int{1, 2}
    a2 = append(a2, a1...) //添加另外一个切片进去
    fmt.Printf("a2: %v\n", a2)
}

输出结果如下

a: [1 2 3 4 5]
---------------------
a2: [1 2 3 4 5]

2. 删除元素

Golang 切片(Slice)实现增删改查

package main
 
import "fmt"
 
func main() {
    var s1 = []int{1, 2, 3, 4}
    fmt.Println("---删除之前---")
    fmt.Printf("s1: %v\n", s1)
 
    //删除3这个元素,它的下标索引为2
    s1 = append(s1[:2], s1[3:]...)
    fmt.Println("---删除之后---")
    fmt.Printf("s1: %v\n", s1)
}

执行结果如下

---删除之前---
s1: [1 2 3 4]
---删除之后---
s1: [1 2 4]

删除元素的公式

要从切片a中删除索引为index的元素,操作方法如下

a = append(a[:index], a[index+1:]...)

3. 修改切片元素

package main
 
import "fmt"
 
func main() {
    var s1 = []int{1, 2, 3, 4, 5}
    s1[1] = 100 //索引1的值改为100
    fmt.Printf("s1: %v\n", s1)
}

输出结果如下

s1: [1 100 3 4 5]

4. 查找切片元素

package main
 
import "fmt"
 
func main() {
    var s1 = []int{1, 2, 3, 4, 5}
    var key = 2 //查找2所在的位置
    for i, v := range s1 {
        if v == key {
            fmt.Printf("s1: %v\n", s1)
            fmt.Printf("索引为: %v\n", i)
        }
    }
}

输出结果如下

s1: [1 2 3 4 5]
索引为: 1

5. 拷贝切片

package main
 
import "fmt"
 
func main() {
    var s1 = []int{1, 2, 3, 4, 5}
    var s2 = s1
    s2[0] = 100
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s2: %v\n", s2)
}

输出结果如下

s1: [100 2 3 4 5]
s2: [100 2 3 4 5]

可以看到当s2的值改变的时候,s1的值也改变了,因为s2复制了s1的是他的内存地址,所以相关联都会改变

使用copy方法修改则不会对源切片的值有影响

package main
 
import "fmt"
 
func main() {
    var s1 = []int{1, 2, 3, 4, 5}
    var s2 = make([]int, 4) //需要make一个切片的类型,指定有5个元素
    copy(s2, s1)    //指定复制的切片
 
    s2[0] = 100
    fmt.Printf("s1: %v\n", s1)
    fmt.Printf("s2: %v\n", s2)
}

输出结果

s1: [1 2 3 4 5]
s2: [100 2 3 4 5]

到此这篇关于Go语言实现切片增删改查的示例代码的文章就介绍到这了!


Tags in this post...

Golang 相关文章推荐
golang判断key是否在map中的代码
Apr 24 Golang
goland 清除所有的默认设置操作
Apr 28 Golang
彻底理解golang中什么是nil
Apr 29 Golang
Go使用协程交替打印字符
Apr 29 Golang
go语言基础 seek光标位置os包的使用
May 09 Golang
Go遍历struct,map,slice的实现
Jun 13 Golang
golang内置函数len的小技巧
Jul 25 Golang
深入理解go slice结构
Sep 15 Golang
golang中的struct操作
Nov 11 Golang
如何利用golang运用mysql数据库
Mar 13 Golang
golang用type-switch判断interface的实际存储类型
Apr 14 Golang
Go gRPC进阶教程gRPC转换HTTP
Jun 16 Golang
Golang 结构体数据集合
Apr 22 #Golang
Golang map映射的用法
Apr 22 #Golang
Golang bufio详细讲解
Apr 21 #Golang
Go获取两个时区的时间差
Apr 20 #Golang
Golang jwt身份认证
实现GO语言对数组切片去重
Apr 20 #Golang
Golang日志包的使用
Apr 20 #Golang
You might like
让你同时上传 1000 个文件 (一)
2006/10/09 PHP
php时间函数用法分析
2016/05/28 PHP
PHP模拟http请求的方法详解
2016/11/09 PHP
全面解析PHP面向对象的三大特征
2017/06/10 PHP
使用Zookeeper分布式部署PHP应用程序
2019/03/15 PHP
js checkbox(复选框) 使用集锦
2009/04/28 Javascript
浅谈JavaScript中定义变量时有无var声明的区别
2014/08/18 Javascript
详解JavaScript中的异常处理方法
2015/06/16 Javascript
鼠标经过子元素触发mouseout,mouseover事件的解决方案
2015/07/26 Javascript
javascript冒泡排序小结
2016/04/10 Javascript
基于RequireJS和JQuery的模块化编程日常问题解析
2016/04/14 Javascript
关于AngularJs数据的本地存储详解
2017/01/20 Javascript
JS简单实现获取元素的封装操作示例
2017/04/07 Javascript
通过一个简单的例子学会vuex与模块化
2017/11/22 Javascript
AjaxUpLoad.js实现文件上传
2018/03/05 Javascript
100行代码实现一个vue分页组功能
2018/11/06 Javascript
优化Vue项目编译文件大小的方法步骤
2019/05/27 Javascript
NodeJs 模仿SIP话机注册的方法
2019/06/21 NodeJs
关于JavaScript数组去重的一些理解汇总
2020/09/10 Javascript
python实现网站的模拟登录
2016/01/04 Python
Python中循环引用(import)失败的解决方法
2018/04/22 Python
Python 忽略warning的输出方法
2018/10/18 Python
Keras 使用 Lambda层详解
2020/06/10 Python
css3圆角边框和边框阴影示例
2014/05/05 HTML / CSS
详解基于canvas的视频遮罩插件
2018/01/04 HTML / CSS
StubHub意大利:购买和出售全球演唱会和体育赛事门票
2017/11/21 全球购物
美国室内盆栽植物购买网站:Plants.com
2020/04/24 全球购物
介绍一下Ruby的多线程处理
2013/02/01 面试题
致100米运动员广播稿
2014/02/14 职场文书
创建青年文明号材料
2014/05/09 职场文书
村党支部书记承诺书
2014/05/29 职场文书
师德师风自我剖析材料
2014/09/27 职场文书
2014小学年度工作总结
2014/12/20 职场文书
2015年大学生党员承诺书
2015/04/27 职场文书
CSS三大特性继承性、层叠性和优先级详解
2022/01/18 HTML / CSS
Python os和os.path模块详情
2022/04/02 Python