Go_切片（初始化、遍历、截取、修改、append、copy、切片作为函数参数、切片求和、切片求最大值）

切片：

  • 切片的长度是不固定的，可以追加数据，可以理解是一个动态数组，切片的底层是一个结构体
  • 切片类型（slice）本身并不是动态数组或数组指针。它内部通过指针引用底层数组，设定相关属性将操作限定在指定范围内。当需要时，会申请更大的内存，将当前数据复制过去, 以实现类似动态数组的功能。
type slice struct { array unsafe.Pointer //  指针，指向底层数组len int // 切片的长度cap int // 切片的容量
}

怎么区分数组和切片：

数组是必须要有长度，不管是显式还是推导都要有长度，但是切片不是一定要显式长度

切片的创建：

可直接创建切片对象，无需预先准备数组。因为是引用类型，必须使用make函数或显式初始化语句，它会自动完成底层数组内存分配

注意：切片定义完后，还不能使用，因为本身是一个空的，需要让其引用到一个数组，或者make一个空间供切片来使用。

在这里插入图片描述

普通格式：

var slice [] type

自动推导类型创建切片：

slice := [] type{}

make函数创建切片：

// len：切片的长度    cap：切片的容量    cap不能大于len，且可省略，默认和len相同
// len和cap：长度是已经初始化的空间，容量是已经开辟的空间，包括已经初始化的空间和空闲的空间
// cap是一个内置函数，用于统计切片的容量，也就是最大可以存放多少个元素
// 仅定义没有写make就相当于创建了切片里面是空的var slice []type = make([]type, len，cap)
var slice = make([]type, len, cap) // 简写

演示：

func main() {var slice []int             // 普通格式创建的slice，空切片slice2 := []int{}           // 自动推导类型创建的slice，空切片slice3 := make([]int, 2)    // make函数创建的slice，省略cap，cap=lenslice4 := make([]int, 2, 3) // make函数创建的slice，自定义capfmt.Println("slice：", slice)fmt.Println("slice2：", slice2)fmt.Println("slice3：", slice3, "len：", len(slice3), "cap：", cap(slice3))fmt.Println("slice4：", slice4, "len：", len(slice4), "cap：", cap(slice4))
}

输出：

slice：  []
slice2： []
slice3： [0 0]  len： 2  cap： 2
slice4： [0 0]  len： 2  cap： 3

引用数组创建：

func main() {// 1. 创建数组arr := [...]int{1, 2, 3, 4, 5}// 2.创建切片并引用数组// slice：切片名// arr[1:3]：引用了数组arr的数据，从索引1到索引3-1（包含索引1但是不包含索引3，也就是arr[2,3]）// slice := arr// 相当于引用数组全部数据slice := arr[1:3]fmt.Println("arr：", arr)// 现在切片中只有 [2 3]，也就是索引0和1，如果用取slice[2]就会越界fmt.Println("slice：", slice)//fmt.Println("slice：", slice[2]) // 报错fmt.Println("slice中元素的个数：", len(slice))fmt.Println("slice的容量：", cap(slice))
}

输出：

arr： [1 2 3 4 5]
slice： [2 3]
slice中元素的个数： 2
slice的容量： 4

引用数组或切片会同步数据

func main() {slice := make([]int, 2, 3)slice[0] = 1slice[1] = 2slice2 := slice[0:]slice2[0] = 100fmt.Println(slice)fmt.Println(slice2)
}

输出：

[100 2]
[100 2]

引用数组简写格式：

slice := arr[0:indexEnd]   简写为   slice := arr[:indexEnd]
slice := arr[indexStart:len(arr)]   简写为    slice := arr[indexStart:]
slice := arr[0:len(arr)]   简写为   slice := arr[:]  或  slice := arr

初始化：

三种创建格式，都是可以通过append向切片添加数据的

初始化格式：

/// 普通格式创建的切片
var slice []type// 自动推导类型创建的切片，这种情况会根据添加的数据推断切片的长度，容量=长度
slice := [] type{数据1,数据2,数据3}// make函数方式创建的切片可以通过append和循环初始化
slice = append(slice, 数据1,数据2...)

演示：

func main() {// var slice []typevar slice []intslice = append(slice, 1, 2, 3, 4) // 通过append添加slice[1] = 111                    // 通过索引添加fmt.Println("切片中的数据", slice)fmt.Println("可以通过索引取部分数据", slice[0])fmt.Println("切片长度：", len(slice), "切片的容量", cap(slice))fmt.Println()// slice := [] type{数据1,数据2,数据3}slice2 := []int{1, 2, 3, 4, 5}slice2 = append(slice2, 6, 7, 8, 9, 10)slice2[1] = 111fmt.Println("切片中的数据", slice2)fmt.Println("可以通过索引取部分数据", slice2[0])fmt.Println("切片长度：", len(slice2), "切片的容量", cap(slice2))fmt.Println()// slice = append(slice, 数据1,数据2...)slice3 := make([]int, 3, 4)for i := 0; i < len(slice3); i++ {slice3[i] = i + 1}slice3 = append(slice3, 1)fmt.Println("切片中的数据", slice3)fmt.Println("可以通过索引取部分数据", slice3[0])fmt.Println("切片长度：", len(slice3), "切片容量：", cap(slice3))
}

输出：

切片中的数据 [1 111 3 4]
可以通过索引取部分数据 1
切片长度： 4 切片的容量 4切片中的数据 [1 111 3 4 5 6 7 8 9 10]
可以通过索引取部分数据 1
切片长度： 10 切片的容量 10切片中的数据 [1 2 3 1]
可以通过索引取部分数据 1
切片长度： 4 切片容量： 4

注意下面两种定义方式的区别。前者仅定义了一个[ ]int类型变量，并未执行初始化操作，而后者则用初始化表达式完成了全部创建过程

func main() {var a []intb := []int{}fmt.Println(a == nil, b == nil) // true false
}

可获取元素地址，但不能向数组那样直接通过指针(*slice)访问元素内容

func main() {s := []int{0, 1, 2, 3, 4}p := &s     // 取切片地址p0 := &s[0] // 取第一个元素地址p1 := &s[1]println(p, p0, p1)// 取p中[1]的数据且加100(*p)[1] += 100 // *[]int不支持indexing操作，须先用指针操作符获取[]int对象fmt.Println(s)fmt.Println((*p)[1]) //这里加括号是优先级问题
}

如果元素类型也是切片，那么就能实现类似交错数组的功能

func main() {x := [][]int{{1, 2},{10, 20, 30},{100},}fmt.Println(x[1])x[2] = append(x[2], 200, 300)fmt.Println(x[2])
}

输出：

[1 2] [10 20 30]
[100 200 300]

切片遍历：

遍历和数组一样可以使用普通的for循环和range遍历得到

func main() {slice := []int{1, 2, 3, 4, 5}for i := 0; i < len(slice); i++ {fmt.Print(slice[i])}for _, v := range slice {fmt.Println(v)}
}

append函数：

append函数是向切片的末尾添加数据
如果添加的内容超出了切片初始定义的容量，切片会自动扩容
扩容机制是：上一次的容量 * 2如果超过1024字节，每次扩容上一次的1/4
append每次扩容都是一个新的内存，和原来的无关联，所以如果是通过参数传递的方式，使用append添加数据，但是不会影响到原切片的数据，原因就是append每次拓展都是一个新的空间，指向的内存不再是原切片。

切片append底层原理：

  1. 创建新的数组并扩容
  2. 将原数组的数据拷贝到新数组
  3. 将新添加的数据添加到新数组
  4. slice引用到新数组
  5. 原数组被程序销毁

格式：

slice = append(slice,数据)

演示：

func main() {slice := make([]int, 3, 4)// 这里定义了切片的长度是3，初始容量是4，系统会对长度赋上默认值，int类型就是0，所以打印3个0fmt.Println("初始切片的数据：", slice, "长度：", len(slice))slice = append(slice, 1)// 添加数据，此时容量是4，数据已经有4个了，如果继续多加点数据，会不会报错fmt.Println("第一次添加数据：", slice, "长度：", len(slice))slice = append(slice, 2, 3, 4)fmt.Println("第二次添加数据：", slice, "长度：", len(slice))// 这里是相当于把自己的数据再添加一遍slice = append(slice, slice...)fmt.Println("第三次添加数据：", slice, "长度：", len(slice))// 再创建一个切片，初始化后把slice的数据添加过来，注意，这个不是复制，是在结尾继续添加slice2 := make([]int, 3, 4)slice2 = append(slice2, slice...)fmt.Println("slice2：", slice2, "长度：", len(slice2))
}

输出：

初始切片的数据： [0 0 0]  长度： 3
第一次添加数据： [0 0 0 1]  长度： 4
第二次添加数据： [0 0 0 1 2 3 4]  长度： 7
第三次添加数据： [0 0 0 1 2 3 4 0 0 0 1 2 3 4]  长度： 14
slice2：       [0 0 0 0 0 0 1 2 3 4 0 0 0 1 2 3 4]  长度： 17

copy函数：

切片是引用类型，新切片复制后，修改数据是不会影响原切片的
注意：如果切片1的容量不够，则不赋值剩余的数据。如果切片1的数据比切片2的多，从切片2复制的数据是有多少，复制多少。
总结：copy只是复制索引相对应的数据，如果长度不够，不会覆盖原来的数据

格式：

copy(切片1,切片2) // 把切片2的数据复制到切片1中

从切片2复制到切片1，但是切片2的数据比切片1的多，所以，最终只是复制了一部分，也就是索引相对应的数据

func main() {slice := []int{1, 2, 3}slice2 := []int{4, 5, 6, 7, 8, 9}copy(slice, slice2) // 把切片2复制到切片1fmt.Println(slice)  // [4 5 6]// 修改数据slice = append(slice, 97, 98)slice2 = append(slice2, 100)fmt.Println(slice)  // [4 5 6 97 98]fmt.Println(slice2) // [4 5 6 7 8 9 100]
}

string底层是一个byte数组，因此string也可以进行切片处理

func main() {b := make([]byte, 3)s := copy(b, "abcde") // 字符串复制数据到[]bytefmt.Println(s) // 3fmt.Println(b) // [97 98 99]
}

切片截取：

切片截取就是从切片中获取指定的数据返回给新切片
如果初始化切片时，没有指定切片的容量，切片容量是跟随原切片的

切片截取的操作：

操作含义
s[n]从切片s的n索引到len(s)-1
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)

在这里插入图片描述

func main() {slice := []int{1, 2, 3, 4, 5}/**第一个值：截取的起始索引第二个值：截取的终止索引（不包括该值）第三个值：用来计算切片的容量，可以省略，默认和长度一样容量 = 第三个值 - 第一个值长度 = 第二个值 - 第一个值*/newSlice := slice[0:3:3]fmt.Println("newSlice：", newSlice, "长度：", len(newSlice), "容量：", cap(newSlice))// 和复制一样了newSlice2 := slice[:]fmt.Println("newSlice2：", newSlice2, "长度：", len(newSlice2), "容量：", cap(newSlice2))
}

输出：

newSlice： [1 2 3] 长度： 3 容量： 3
newSlice2： [1 2 3 4 5] 长度： 5 容量： 5
切片值的修改：

切片截取后返回新切片，对新切片的值进行修改，会影响原来的切片

原因：

切片截取后新的切片是指向了原来的切片，没有给新的切片开辟新的空间，所以对于新的切片操作会影响到原来的切片

演示：

func main() {slice := []int{1, 2, 3, 4, 5}newSlice2 := slice[0:3]fmt.Println("切片修改前slice的数据：", slice)newSlice2[0] = 1111fmt.Println("切片修改后slice的数据：", slice)
}

输出：

切片修改前slice的数据： [1 2 3 4 5]
切片修改后slice的数据： [1111 2 3 4 5]

切片作为函数参数：

切片可以做为函数的参数，但是在函数中修改切片的值，会影响到原切片

因为切片的底层是结构体，结构体里有个参数Pointer，Pointer会指向切片的内存地址，使用的是浅拷贝方式，所以会影响到原切片值

演示

func main() {slice := make([]int, 10)SliceDemo(slice)fmt.Println(slice) // [0 1 2 3 4 5 6 7 8 9]}func SliceDemo(slice []int) {for i := 0; i < len(slice); i++ {slice[i] = i}
}

使用append就不会影响，而且内存地址都不一样怎么会影响呢？因为append会变成一个新的切片

func main() {slice := []int{1, 2, 3, 4, 5}SliceDemo(slice)fmt.Println("main:", slice)fmt.Printf("main：%p", slice)
}func SliceDemo(slice []int) {slice = append(slice, 6, 7)fmt.Println("SliceDemo:", slice)fmt.Printf("SliceDemo：%p\n", slice)
}

输出：

SliceDemo: [1 2 3 4 5 6 7]
SliceDemo：0x1400001c0a0
main: [1 2 3 4 5]
main：0x14000014180

去掉append，内存地址就一样了

func main() {slice := []int{1, 2, 3, 4, 5}SliceDemo(slice)fmt.Println("main:", slice)fmt.Printf("main：%p", slice)
}func SliceDemo(slice []int) {fmt.Println("SliceDemo:", slice)fmt.Printf("SliceDemo：%p\n", slice)
}

输出：

SliceDemo: [1 2 3 4 5]
SliceDemo：0x14000014180
main: [1 2 3 4 5]
main：0x14000014180

切片求和：

func main() {// 定义变量，并收集用户输入的个数var count intfmt.Println("请输入要求和的个数：")fmt.Scan(&count)// 定义切片，将输入的个数保存到切片slice := make([]int, count)statisticalData(slice)// 求和summation(slice)
}func statisticalData(slice []int) {for i := 0; i < len(slice); i++ {fmt.Printf("请输入第%d个数\n", i+1)fmt.Scan(&slice[i])}
}
func summation(slice []int) {var sum intfor i := 0; i < len(slice); i++ {sum += slice[i]}fmt.Println("和为：", sum)
}

切片求最大值：

func main() {// 定义变量，并收集用户输入的个数var count intfmt.Println("请输入要比较的数：")fmt.Scan(&count)// 定义切片，将输入的个数保存到切片slice := make([]int, count)statisticalData(slice)// 比较最大值maximum(slice)
}func statisticalData(slice []int) {for i := 0; i < len(slice); i++ {fmt.Printf("请输入第%d个数\n", i+1)fmt.Scan(&slice[i])}
}func maximum(slice []int) {max := slice[0]for i := 0; i < len(slice); i++ {if max < slice[i] {max = slice[i]}}fmt.Println("最大值是：", max)
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/572116.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Golang——递归的使用

Golang——递归的使用

递归指的是函数定义中调用函数本身的现象&#xff08;自己调自己&#xff09;把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算 递归注意事项&#xff1a; 递归一定要有出口。否则内存溢出(出口…
阅读更多...
阿里巴巴Java开发手册——速读记录

阿里巴巴Java开发手册——速读记录

本随笔基于阿里巴巴Java开发手册V1.2&#xff0c;陆陆续续记录一些现阶段能理解的&#xff0c;有启发的内容&#xff0c;并将持续更新 最佳实践——插件使用已经发布为随笔&#xff01;http://www.cnblogs.com/jiangbei/p/7668654.html 一、编程规范 1.命名规范 &#xff08;1&…
阅读更多...
Go_map集合初始化、键值操作、map作为函数参数的使用

Go_map集合初始化、键值操作、map作为函数参数的使用

map&#xff1a; map是key-value的数据结构&#xff0c;类似于Java的集合&#xff0c;又称为字典&#xff0c;像新华字典就是key:value类型展示的map是无序的&#xff0c;其中key是不允许重复的&#xff0c;key不存在相当于添加&#xff0c;存在相当于修改map的key必须可以进行…
阅读更多...
Angular 小试牛刀[1]:Getting Started

Angular 小试牛刀[1]:Getting Started

首先&#xff0c;Angular2 与 Angular1.x 版本没有多大关系&#xff0c;甚至可以说是两个完全不一样的框架&#xff0c;故 Angular 指的是 Angular2 及以上的版本。而 Angular 与 TypeScript 的完美结合&#xff0c;对于一个 .NET 开发者来说&#xff0c;实在是找不到不用它的理…
阅读更多...
Go_指针的使用、数组指针和指针数组、指针与切片、指针与结构体、多级指针

Go_指针的使用、数组指针和指针数组、指针与切片、指针与结构体、多级指针

指针&#xff1a; 指针是一个特殊的变量&#xff0c;因为它存储的数据是另一个变量的内存地址&#xff0c;指针本身也是有内存地址的指针的数据类型有int、float、bool、string、数组、结构体指针的作用就是可以通过变量/对象的内存地址去操作变量/对象 注意&#xff1a; 取址运…
阅读更多...
linux驱动编写（Kconfig文件和Makefile文件）

linux驱动编写（Kconfig文件和Makefile文件）

在Linux编写驱动的过程中&#xff0c;有两个文件是我们必须要了解和知晓的。这其中&#xff0c;一个是Kconfig文件&#xff0c;另外一个是Makefile文件。如果大家比较熟悉的话&#xff0c;那么肯定对内核编译需要的.config文件不陌生&#xff0c;在.config文件中&#xff0c;我…
阅读更多...
Go_结构体与数组、切片、map、方法、作为函数参数、type、Tag

Go_结构体与数组、切片、map、方法、作为函数参数、type、Tag

结构体&#xff1a; 结构体是由一系列具有相同类型或不同类型的数据构成的数据集合结构体可以很好的管理数据&#xff0c;使用结构体可以提高程序的易读性&#xff0c;类似于Java的类一样结构体内成员名必须唯一&#xff0c;可用_补位&#xff0c;支持使用自身类型的指针成员。…
阅读更多...
vue项目中如何引入ElementUI

vue项目中如何引入ElementUI

1.在cmd中输入命令&#xff1a; npm i element-ui -S 2.在src/main.js文件中增加代码&#xff1a; import ElementUI from element-ui import element-ui/lib/theme-default/index.cssVue.use(ElementUI) 转载于:https://www.cnblogs.com/xuemei/p/7372332.html
阅读更多...
Golang——深浅拷贝

Golang——深浅拷贝

浅拷贝&#xff1a;只是拷贝了内存地址&#xff0c;会指向原来的内存&#xff0c;指向原来的内存地址&#xff0c;操作的时候会互相影响 go中的赋值、函数传参、函数返回值都是浅拷贝 深拷贝&#xff1a;会把变量的数据都拷贝一份&#xff0c;包括地址&#xff0c;新的内存地址…
阅读更多...
[Java][web]利用Spring随时随地获得Request和Session

[Java][web]利用Spring随时随地获得Request和Session

利用Spring随时随地获得Request和Session 一、准备工作&#xff1a; 在web.xml中加入 <listener> <listener-class> org.springframework.web.context.request.RequestContextListener</listener-class> </listener>二、用法&#xff1a;…
阅读更多...
Golang实现通讯录小案例

Golang实现通讯录小案例

代码&#xff1a; package mainimport "fmt"func main() {for {menu()} }type User struct {userName string/**key&#xff1a;表示电话的类型value&#xff1a;电话号码*/addressPhone map[string]string }// 定义切片 var userList make([]User, 0)func menu() …
阅读更多...
MySql5.6版修改用户登录密码

MySql5.6版修改用户登录密码

1、使用 mysqladmin 方式: 打开命令提示符界面, 执行命令: mysqladmin -u root -p password 新密码 执行后提示输入旧密码完成密码修改, 当旧密码为空时直接按回车键确认即可。 2、UPDATE user 语句&#xff08;我自己用的就是这个方法&#xff09; 这种方式必须是先用root帐户…
阅读更多...
Go_面向对象（抽象、封装、继承）

Go_面向对象（抽象、封装、继承）

抽象 抽象是一种编程思维方式&#xff0c;是从多个事物中提取共性 例&#xff1a;产品经理和程序员都有工作的方法&#xff0c;但是工作内容不同&#xff0c;可以把工作抽象出来定义为一个方法&#xff0c;具体细节由调用者补充 银行存取款案例&#xff1a; 账号结构体取款方法…
阅读更多...
Go_接口、多态、接口继承与转换、空接口、类型断言

Go_接口、多态、接口继承与转换、空接口、类型断言

接口 接口用于定义对象的行为&#xff0c;接口只指定对象应该做什么&#xff0c;实现这种行为由对象来决定。接口只是把所有具有共性的方法定义在一起&#xff0c;任何类型实现了接口中所有的方法&#xff0c;就是实现了这个接口。接口存在的意义就是用来定义规范&#xff0c;…
阅读更多...
Discrete Logging POJ - 2417（BSGS）

Discrete Logging POJ - 2417（BSGS）

Discrete Logging POJ - 2417 题意&#xff1a;给P&#xff0c;B&#xff0c;N&#xff0c;求最小的L使得 BL≡N (mod P)&#xff0c;其中P是素数。 Baby Step Giant Step 1 #include <cstdio>2 #include <cstring>3 #include <iostream>4 #include <cma…
阅读更多...
Go_error处理及panic、recover使用的正确姿势

Go_error处理及panic、recover使用的正确姿势

异常 异常就是程序出现了不正常的情况&#xff0c;会导致程序非正常停止&#xff0c;而异常处理就是针对非正常停止的情况&#xff0c;给出异常时的处理方式。语法错误不算异常体系中 error&#xff1a; error是一个接口&#xff0c;作用是返回程序异常的信息&#xff0c;err…
阅读更多...
js 根据固定位置获取经纬度--腾讯地图

js 根据固定位置获取经纬度--腾讯地图

1.首先引入jq 和 腾讯地图js <script src"../js/jQuery.js"></script> <script charset"utf-8" src"http://map.qq.com/api/js?v2.exp"></script> 2.html代码部分 <body onload"init()"><button ty…
阅读更多...
Go_文件/目录创建、写入、追加、读取、缓冲区、Stat、IsNotExist、Copy

Go_文件/目录创建、写入、追加、读取、缓冲区、Stat、IsNotExist、Copy

操作目录 创建目录 Mkdir&#xff1a;创建单个目录MkdirAll&#xff1a;创建多级目录 func main() {err : os.Mkdir("/Users/itzhuzhu/Desktop/笔记/英语/a", os.ModePerm)if err ! nil {fmt.Println("创建失败", err)} else {fmt.Println("创建成…
阅读更多...
【bzoj3343】教主的魔法 (分块 + 二分)

【bzoj3343】教主的魔法 (分块 + 二分)

传送门(权限题) 题目分析 题意为&#xff1a;给定一个数列&#xff0c;修改和查询两种操作&#xff0c;修改每次给定一个区间&#xff0c;区间的所有元素都加上一个给定值&#xff0c;查询询问一段区间的数权值大于等于给定值的数有多少个。 首先对原序列分块&#xff0c;然后将…
阅读更多...
Golang——string字符串常用函数（Contains、join、Index、Repeat、Replace、Split、Trim、Fields）

Golang——string字符串常用函数（Contains、join、Index、Repeat、Replace、Split、Trim、Fields）

更多的还是去官方文档里去看&#xff1a;https://studygolang.com/pkgdoc Contains&#xff1a; 判断字符串中是否包含指定字符串 演示&#xff1a; func main() {str1 : "itzhuzhu"result : strings.Contains(str1, "zhu")fmt.Println(result) }join&a…
阅读更多...
最新文章

Copyright @ 2022~2023