Golang学习（五）：数组与切片

最新推荐文章于 2024-02-01 14:23:33 发布
最新推荐文章于 2024-02-01 14:23:33 发布
阅读量369 收藏
点赞数
分类专栏： Golang学习 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41433002/article/details/124541177
版权

文章目录

1. 数组

1.1 数组定义和内存布局

  1. 定义
var 数组名 [数组大小]数据类型
var a [5]int
  1. 内存布局
    ① &intArr可以获取地址
    ② 第一个元素地址就是数组的首地址
    ③ 地址间隔由数组类型决定（前一个元素地址，每个元素占用的字节数）
    在这里插入图片描述

1.2 数组的访问和初始化

  1. 访问
    java一样，下标志访问
  2. 四种初始化方式
	//1.
	var numArr01 [3]int = [3]int{1, 2, 3}
	//2.
	var numArr02 = [3]int{5, 6, 7}
	//3.这里的 [...] 是规定的写法
	var numArr03 = [...]int{8, 9, 10}
	//4.注明下标
	var numArr04 = [...]int{1: 800, 0: 900, 2:999}
	//类型推导
	strArr05 := [...]string{1: "tom", 0: "jack", 2:"mary"}

package main
import (
	"fmt"
)

func main() {

	var intArr [3]int //int占8个字节
	//当我们定义完数组后，其实数组的各个元素有默认值 0
	fmt.Println(intArr)
	intArr[0] = 10
	intArr[1] = 20
	intArr[2] = 30
	fmt.Println(intArr)
	fmt.Printf("intArr的地址=%p intArr[0] 地址%p intArr[1] 地址%p intArr[2] 地址%p\n", 
		&intArr, &intArr[0], &intArr[1], &intArr[2])


	//从终端循环输入5个成绩，保存到float64数组,并输出.
	// var score [5]float64

	// for i := 0; i < len(score); i++ {
	// 	fmt.Printf("请输入第%d个元素的值\n", i+1)
	// 	fmt.Scanln(&score[i])
	// }
	
	// //变量数组打印
	// for i := 0; i < len(score); i++ {
	// 	fmt.Printf("score[%d]=%v\n", i, score[i])
	// }

	//四种初始化数组的方式
	var numArr01 [3]int = [3]int{1, 2, 3}
	fmt.Println("numArr01=", numArr01)

	var numArr02 = [3]int{5, 6, 7}
	fmt.Println("numArr02=", numArr02)
	//这里的 [...] 是规定的写法
	var numArr03 = [...]int{8, 9, 10}
	fmt.Println("numArr03=", numArr03)

	var numArr04 = [...]int{1: 800, 0: 900, 2:999}
	fmt.Println("numArr04=", numArr04)

	//类型推导
	strArr05 := [...]string{1: "tom", 0: "jack", 2:"mary"}
	fmt.Println("strArr05=", strArr05)
}

1.3 数组遍历

第一种：常规for int 遍历
第二种：for-range
在这里插入图片描述

package main
import (
	"fmt"
)

func main() {

	//演示for-range遍历数组
	 heroes  := [...]string{"宋江", "吴用", "卢俊义"}
	//使用常规的方式遍历，我不写了..

	for i, v := range heroes {
		fmt.Printf("i=%v v=%v\n", i , v)
		fmt.Printf("heroes[%d]=%v\n", i, heroes[i])
	}

	for _, v := range heroes {
		fmt.Printf("元素的值=%v\n", v)
	}
}

1.4 数组注意事项

  1. Go数组默认值传递，进行拷贝数组间不影响，如果相在其他函数中更改原来数组使用引用传递
    在这里插入图片描述
    在这里插入图片描述
  2. 传递数组时要考虑长度
    在这里插入图片描述

2. 切片

2.1 切片的内存布局

在这里插入图片描述

package main
import (
	"fmt"
)

func main() {

	//演示切片的基本使用
	var intArr [5]int = [...]int{1, 22, 33, 66, 99}
	//声明/定义一个切片
	//slice := intArr[1:3]
	//1. slice 就是切片名
	//2. intArr[1:3] 表示 slice 引用到intArr这个数组 
	//3. 引用intArr数组的起始下标为 1 , 最后的下标为3(但是不包含3)    
	slice := intArr[1:3] 
	fmt.Println("intArr=", intArr)
	fmt.Println("slice 的元素是 =", slice) //  22, 33
	fmt.Println("slice 的元素个数 =", len(slice)) // 2
	fmt.Println("slice 的容量 =", cap(slice)) // 切片的容量是可以动态变化  

	fmt.Printf("intArr[1]的地址=%p\n", &intArr[1])
	fmt.Printf("slice[0]的地址=%p slice[0==%v\n", &slice[0], slice[0])
	slice[1] = 34
	fmt.Println()
	fmt.Println()
	fmt.Println("intArr=", intArr)
	fmt.Println("slice 的元素是 =", slice) //  22, 33

}

2.2 切片的使用

  1. 定义一个切片，引用一个已经创建好的数组，比如前面这个案例
  2. make创建切片
    基本语法：var 切片名 []type = make([]type, len, [cap])
  3. 定义一个切片直接指定具体数组
package main
import (
	"fmt"
)

func main() {

	//演示切片的使用 make
	var slice []float64 = make([]float64, 5, 10)
	slice[1] = 10
	slice[3] = 20
	//对于切片，必须make使用.
	fmt.Println(slice)
	fmt.Println("slice的size=", len(slice))
	fmt.Println("slice的cap=", cap(slice))


	//方式3
	fmt.Println()
	//第3种方式：定义一个切片，直接就指定具体数组，使用原理类似make的方式
	var strSlice []string = []string{"tom", "jack", "mary"}
	fmt.Println("strSlice=", strSlice)
	fmt.Println("strSlice size=", len(strSlice)) //3
	fmt.Println("strSlice cap=", cap(strSlice)) // ?

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.3 切片的遍历

  1. 常规gor
  2. for-range

2.4 使用注意

  1. 切片可以继续切片
  2. append可以对切片进行动态追加
    在这里插入图片描述
  3. copy函数可以实现拷贝
  4. 在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

package main
import (
	"fmt"
)

func main() {

	//使用常规的for循环遍历切片
	var arr [5]int = [...]int{10, 20, 30, 40, 50}
	//slice := arr[1:4] // 20, 30, 40
	slice := arr[1:4]
	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%v]=%v ", i, slice[i])
	}

	fmt.Println()
	//使用for--range 方式遍历切片
	for i, v := range slice {
		fmt.Printf("i=%v v=%v \n", i, v)
	}

	slice2 := slice[1:2] //  slice [ 20, 30, 40]    [30]
	slice2[0] = 100  // 因为arr , slice 和slice2 指向的数据空间是同一个，因此slice2[0]=100，其它的都变化

	fmt.Println("slice2=", slice2)
	fmt.Println("slice=", slice)
	fmt.Println("arr=", arr)

	fmt.Println()

	//用append内置函数，可以对切片进行动态追加
	var slice3 []int = []int{100, 200, 300}
	//通过append直接给slice3追加具体的元素
	slice3 = append(slice3, 400, 500, 600)
	fmt.Println("slice3", slice3) //100, 200, 300,400, 500, 600

	//通过append将切片slice3追加给slice3
	slice3 = append(slice3, slice3...) // 100, 200, 300,400, 500, 600 100, 200, 300,400, 500, 600
	fmt.Println("slice3", slice3)


	//切片的拷贝操作
	//切片使用copy内置函数完成拷贝，举例说明
	fmt.Println()
	var slice4 []int = []int{1, 2, 3, 4, 5}
	var slice5 = make([]int, 10)
	copy(slice5, slice4)
	fmt.Println("slice4=", slice4)// 1, 2, 3, 4, 5
	fmt.Println("slice5=", slice5) // 1, 2, 3, 4, 5, 0 , 0 ,0,0,0
}

2.5 String 和 slice

  1. String 底层 Byte 数组，可以切片
    在这里插入图片描述

  2. String 和切片在内存的形式
    在这里插入图片描述

  3. String 不可变，不能通过 str[0]=‘z’ 方式修改字符串
    在这里插入图片描述

  4. 要修改字符串，先把string——[]byte，或者[]rune——修改——重写成string
    在这里插入图片描述

平什么阿
关注
专栏目录
Golang学习笔记 - 08 :循环语句
u011682283的博客
06-26 408
for Go语言的For循环有3中形式，只有其中的一种使用分号。 和 C 语言的 for 一样： for init; condition; post { } 和 C 的 while 一样： for condition { } 和 C 的 for(;;) 一样： for { } init一般为赋值表达式，给控制变量赋初值 condition关系表达式或逻辑表达式，循环控制条件 post一般为赋...
Golang：数组与切片的复制
ミ安之偌素
06-09 2734
在Golang中，数组是值类型而切片是引用类型。因此值的复制与切片的复制并不相同。 数组的复制 对于值类型的数组来说，变量指向的并不是第一个元素的指针，而是整个数组。以下情况会发生数组的复制： 将数组变量赋值给另一个数组变量 将数组变量作为参数传递给方法 举个栗子： package main import "fmt" func main() { sample1 := [2]string{"a", "b"} fmt.Printf("Sample1 Before: %v\n", samp
golang切片容量计算
蜗牛^_^的博客
10-15 2104
提到切片，我们需要对比数组进行理解： 数组类型的值的长度是固定的，切片类型的值是可变长度的； 数组可以被叫做切片的底层数组，切片可以看作是对数组的某个连续片段的引用； 切片类型是引用类型，数组属于值类型； len表示长度，cap表示容量。数组的容量等于长度；切片的容量不一定等于长度，切片的容量代表了底层数组的长度。 本文主要围绕切片的容量进行展开。 1）使用make初始化切片 s1:=make([]int,5,8) 指明容量，长度为5，容量是8 s2:=make([]int,5) 不指明容量，那么和长度是
【Go语言】一文了解数组和切片区别（内存结构）
weixin_44938441的博客
12-01 901
文章目录引子定义内存结构（！！！）内置方法总结 引子 数组和切片是我们较为常用的数据结构，正是因为他们的普遍，其中有许多小问题都被我们忽略掉了，比如说： 1.在作为参数传递时，为什么切片的改动会使得原来的实参也发生变化，而数组的改动就不会影响到实参 2.为什么数组的类型会因为长度不同而无法兼容，但是切片却可以随意传递，两者的内存布局到底是什么样的 3.为什么数组偏向静态的不能追加，而切片却可以动态扩容 … 定义 先从定义开始 数组常用的定义方法： var arr_1 = [...]int{1,2,3}//[
Go数组array和切片Slice以及扩容
General_zy的博客
05-04 1017
nil 切片的指针指向 nil。切片的结构体由3部分构成，Pointer 是指向一个数组的指针，len 代表当前切片的长度，cap 是当前切片的容量。新的切片和之前的切片已经不同了，因为新的切片更改了一个值，并没有影响到原来的数组，新切片指向的数组是一个全新的数组。空切片和 nil 切片的区别在于，空切片指向的地址不是nil，指向的是一个内存地址，但是它没有分配任何内存空间，即底层元素包含0个元素。可以看到，Go1.18的扩容策略中，随着容量的增大，其扩容系数是越来越小的，可以更好地节省内存。
Golang 使用For循环中赋值切片，切片内数值相同
猫轻王的博客
02-10 2977
当切片Slice 循环赋值到另一个切片 res 后，res 切片内数值一样，可能是由于取地址的问题。
Golang切片与数组
weixin_53623989的博客
02-01 1452
在Go语言中，数组是具有相同数据类型的元素的有序集合。数组的长度是固定的，且在创建后无法更改。var arr [5]int // 声明一个包含5个整数的数组切片是对数组的一层抽象，它是一个引用类型，由三个部分组成：指针、长度和容量。var slice []int // 定义一个整型切片通过解析Golang中的切片与数组，我们了解了它们的定义、初始化、区别以及实际应用。切片的动态增长特性使其在容器和数据封装方面非常强大，而数组则适用于大小固定且性能要求较高的场景。
参照Java学Go（三）—— go的内置类型：数组、切片slice、map
mingjia1987的博客
05-29 2906
    前一篇说到了go的变量、常量和基本数据类型，接下来继续说一下go的其他内置类型：数组、切片（slice）和集合（map）    一，数组    go和java中肯定都有数组了，只不过在定定义上和定义变量类似，把类型放到了后边（还是觉得很难受有没有？）    首先对比一下定义：//java： int[] arr; //没有初始化 arr = new int[1]{}; ...
Golang-切片与数组的关系及性能
qq_23587709的博客
03-01 646
1. 切片的本质 在go语言当中，切片（slice）是使用最为频繁的数据结构之一，其原因在于它在处理同类型数据序列有着方便且高效的特点，所以今天我就来和大家聊聊我对切片的理解！ 1.1 数组 首先，谈到切片，肯定是不能避开数组的，因为切片是在数组之上的抽象数据类型。数组由长度和类型两部分组成，如[3]int类型表示由 3 个 int 整型组成的数组。数组以索引方式进行访问，例如表达式 s[n] 访问数组的第 n 个元素。数组的长度是固定的，长度是数组类型的一部分。长度不同的 2 个数组是不可以相互赋值
Golang切片与数组：内在差异的深度解析
最新发布
08-06
Golang，通常被称为Go语言，是一种由谷歌开发的编程语言。它以简洁、高效、安全著称，并且非常适合构建大规模的分布式系统和微服务。Go语言的一些主要特点包括： 1. **简洁性**：Go语言的语法非常简单，易于学习。 ...
Golang算法问题之数组按指定规则排序的方法分析
09-21
### Golang算法问题之数组按指定规则排序的方法分析 #### 背景介绍 在处理数据结构时，经常需要对数组或列表中的元素按照特定的规则进行排序。本篇文章将探讨如何在Go语言中实现这样的功能，即对于一个多维数组...
golang学习之七：for 语句的常见“坑”与避坑方法
java_xxxx的博客
07-23 1314
1.凡是用到for-range的地方一定要小心2.凡是用到闭包的地方，参数取值或传参一定要小心3.go方法的本质，也就是 一个以方法的receiver参数作为第一个参数的普通函数4.for-range的时候，如果调用闭包千千万万要看清在将函数注册到函数栈上时有没有注册参数：若有：则注意参数的类型是指针还是非指针。若没有：那么函数运行时，就找闭包函数之外的变量运行了，注意此时变量的值。
转载：Golang——for循环的两种用法
程序员写的技术 FAQ 和杂文
07-28 3960
Golang——for循环的两种用法 PS，作者写的简单易懂明确。只是讲 go 的二种 for 循环。 06 August 2014 一般语言都支持两种遍历方式，这里做下介绍。最后介绍一个 For Range 不恰当的使用引起的 Bug。 从大一开始学C++，所接触过的for循环只有一种方式，for (int i = 0; i < count; i++) {...}。后来接触...
go 创建切片
开发之路
12-21 1337
package main import "fmt" func main() { //自动推导类型，同时进行初始化 s1 := []int{1,2,3,4} fmt.Println("s1=",s1) //借助make的方式创建切片（类型 长度 容量） s2 := make([]int,5,10) ...
Go语言切片详解
热门推荐
技术宅拯救世界
05-20 1万+
切片（slice）是对数组的一个连续片段的引用，所以切片是一个引用类型（因此更类似于 C/C++ 中的数组类型，或者 Python 中的 list 类型），这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集，需要注意的是，终止索引标识的项不包括在切片内。 Go语言中切片的内部结构包含地址、大小和容量，切片一般用于快速地操作一块数据集合，如果将数据集合比作切糕的话，切片就是你要的“那一块”，切的过程包含从哪里开始（切片的起始位置）及切多大（切片的大小），容量可以理解为装切片的口袋大小，如下图所
十分钟讲明白， golang, Go 语言切片(Slice)
Jaylon Wang的专栏
08-21 1万+
Go 语言切片(Slice) Go 语言切片是对数组的抽象。 Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。 定义切片 你可以声明一个未指定大小的数组来定义切片： var identifier []type 切片
Go 切片内存分配
廖圣平
08-15 562
切片是数组的抽象。 切片使用数组作为底层结构。 切片包含三个组件：容量，长度和指向底层数组的指针。 通过使用 append 或 copy 函数可以增加切片的容量。 append 函数可以为数组的末尾增加值，并在需要时增加容量。 s :=[]string{} // for i:=0;i<10;i++ { s = append(s,"i") t.Log(len(s),cap(s)) } slice_test.go:25: 1 1 slice_test.go:25: 2 2 s
Golang 切片详解一 内存布局
qq_24599471的博客
05-08 1088
package main import ( "fmt" "unsafe" ) func main() { fmt.Println() // 切片 // 创建一个切片给变量a，这个切片的长度为0，其底层数组长度为8（常称之为容量） // 切片a的数据结构 struct{ptr: 0x0, len: 0, cap: 8} 占用24字节（72位） // ptr：占8字节 是一个指针 ...
切片（内存优化）
weixin_33743661的博客
01-14 334
2019独角兽企业重金招聘Python工程师标准>>> ...
Go语言学习：动态数组与切片（slice）详解
"Go语言与多维数组及切片（slice）的关系，5G无人机应用白皮书提及的编程概念" 在Go语言中，数组和切片（slice）是两种非常重要的数据结构，它们在存储和操作数据时起着关键作用。数组是固定大小的序列，一旦创建就...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平什么阿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值