golang基础篇(二)【数组与切片】

最新推荐文章于 2023-10-17 10:00:45 发布
最新推荐文章于 2023-10-17 10:00:45 发布
阅读量197 收藏 1
点赞数
分类专栏： go基础篇
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guohuGH/article/details/108314303
版权

数组

定义： 固定长度且拥有零个或者多个相同数据类型元素的序列,数组组成：长度和元素
概念：

  1. 数组是值类型（非指针传参情况时，会对原始数据进行数据复制，修改参数时不更改原始数组）
  2. 数组长度定义后就不可更改，可以使用常量表达式定义长度（编译时会及计算结果）
  3. 数组索引从0开始，内置len函数返回数组元素个数，数组的长度是数组的一部分
  4. go语言支持多维数组，支持range遍历

声明方式

  • 普通声明
package main

import "fmt"

func main() {
	// 声明长度为3的int类型数组，默认数组元素都是零值，int的零值是0
	var arr [3]int
	for i, v := range arr {
		fmt.Printf("index:%d,value:%d ,type：%T ", i, v)
		fmt.Println()
	}

	// 声明长度为3的string类型数组，默认数组元素都是零值，string的零值是空
	var arrStr [3]string
	for i, v := range arrStr {
		fmt.Printf("index:%d,value:%s ,type：%T ", i, v)
		fmt.Println()
	}
}

out

index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string 
index:1,value:2 ,type：string 
index:2,value:3 ,type：string
  • 字面量声明
package main

import "fmt"

func main() {
	// 声明长度为3的int类型数组，并且初始化数组元素,打印类型
	var arr [3]int = [3]int{1, 2, 3}
	for i, v := range arr {
		fmt.Printf("index:%d,value:%d ,type：%T", i, v, v)
		fmt.Println()
	}

	// 声明长度为3的string类型数组,并且初始化数组元素,打印类型
	var arrStr [3]string = [3]string{"1", "2", "3"}
	for i, v := range arrStr {
		fmt.Printf("index:%d,value:%s ,type：%T ", i, v, v)
		fmt.Println()
	}
}

out

index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string 
index:1,value:2 ,type：string 
index:2,value:3 ,type：string
  • 字面量扩展声明
package main

import "fmt"

func main() {
	// 声明int类型数组,数组长度根据元素个数推断
	arr := [...]int{1, 2, 3}
	for i, v := range arr {
		fmt.Printf("index:%d,value:%d ,type：%T", i, v, v)
		fmt.Println()
	}

	// 声明string类型数组,数组长度根据元素个数推断
	arrStr := [...]string{"1", "2", "3"}
	for i, v := range arrStr {
		fmt.Printf("index:%d,value:%s ,type：%T ", i, v, v)
		fmt.Println()
	}
}

out

index:0,value:1 ,type：int
index:1,value:2 ,type：int
index:2,value:3 ,type：int
index:0,value:1 ,type：string 
index:1,value:2 ,type：string 
index:2,value:3 ,type：string
  • 索引声明
package main

import "fmt"

func main() {
	// 声明string类型数组,指定索引位置生成指定元素，其他的全部省略
	// 这里声明的索引位置是3，表示下面定义了一个长度为4的数组，索引3处是"3",其他全是空
	arrStr := [...]string{3: "3"}
	for i, v := range arrStr {
		fmt.Printf("index:%d,value:%s,type：%T ", i, v, v)
		fmt.Println()
	}
}

out

index:0,value:,type：string 
index:1,value:,type：string 
index:2,value:,type：string 
index:3,value:3,type：string
数组比较

数组比较定义：如果一个数组元素类型是可比较的，这个数组就是可比较的

package main

import "fmt"

func main() {
	// 声明方式不同，但是最终的数组是一样的
	arr1 := [3]int{1, 2, 3}
	arr2 := [...]int{1, 2, 3}
	fmt.Printf("arr1 == arr2 => %v", arr1 == arr2)
	// arr1 == arr2=>true

	arr3 := [3]int{1, 2, 3}
	arr4 := [...]int{1, 2, 3, 4}
	// 数组的长度是数组的一部分，如果长度不同，直接报错，无法比较
	// cannot compare arr3 == arr4 (mismatched types [3]int and [4]int)
	fmt.Printf("arr3 == arr4 => %v", arr3 == arr4)// 报错了
}

访问与遍历

  • 索引访问
func main() {
	// 索引访问
	arr := [...]int{1, 2, 3}
	fmt.Printf("arr index 0  =  %v", arr[0])
}

out

arr index 0  =  1
  • 遍历
func main() {
	// 索引遍历
	arr := [...]int{1, 2, 3}
	for i := 0; i < len(arr); i++ {
		fmt.Printf("index: %d, value: %v", i, arr[i])
		fmt.Println()
	}
}

func main() {
	// range 遍历
	arr := [...]int{1, 2, 3}
	for index, value := range arr {
		fmt.Printf("index: %d, value: %v", index, value)
		fmt.Println()
	}
}

out

index: 0, value: 1
index: 1, value: 2
index: 2, value: 3
//=========================
index: 0, value: 1
index: 1, value: 2
index: 2, value: 3
数组传参
  • 副本传参
func main() {
	// 索引遍历
	arr := [...]int{1, 2, 3}
	test(arr)
	// 调用test之后，打印arr元素
	for index, value := range arr {
		fmt.Printf("main index: %d, value: %v", index, value)
		fmt.Println()
	}
}

func test(arr [3]int) {
    // 这里改变index 1处的value
	arr[1] = 100
	for index, value := range arr {
		fmt.Printf("test index: %d, value: %v", index, value)
		fmt.Println()
	}
}

out

test index: 0, value: 1
test index: 1, value: 100
test index: 2, value: 3

main index: 0, value: 1
main index: 1, value: 2
main index: 2, value: 3
  • 指针传参
func main() {
	// 索引遍历
	arr := [...]int{1, 2, 3}
	test(&arr)
	for index, value := range arr {
		fmt.Printf("main index: %d, value: %v", index, value)
		fmt.Println()
	}
}

func test(arr *[3]int) {
	arr[1] = 100
	for index, value := range arr {
		fmt.Printf("test index: %d, value: %v", index, value)
		fmt.Println()
	}
}

out

test index: 0, value: 1
test index: 1, value: 100
test index: 2, value: 3

main index: 0, value: 1
main index: 1, value: 100
main index: 2, value: 3

切片

  • 定义：可变长度且拥有零个或者多个相同数据类型元素的序列
  • 属性：指针，长度，容量
    • 指针：指向数组第一个可以从slice中访问的元素
    • 长度：slice的元素个数
    • 容量：slice的起始元素到数组的最后一个元素之间的个数
  • 一个数组可以对应多个slice，并且如果有切片引用了数组，数组不会被回收
查看切片属性
  • 长度与容量
func main() {
	// 引用数组
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	s := arr[2:5] // index 2~4
	fmt.Printf(" slice is %v ", s)
	fmt.Println()
	fmt.Printf(" slice len is %v , cap is  %v ", len(s), cap(s))
	fmt.Println()
}

out

 slice is [2 3 4] 
 slice len is 3 , cap is  8 // 容量是从index 2 开始到 index 9 结束 => 8
创建切片
  • 直接引用数组:
    • [i:j] 左闭右开区间
func main() {
	// 引用数组
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	// [i:j] 0<= i <= j <= cap(arr)
	// 切片引用的序列为 索引第i个(包含i) 到  第j-1个 左闭右开区间
	s := arr[0:10] // index 0~9
	s2 := arr[:]   // index 0~9
	s3 := arr[2:]  // index 2~9
	s4 := arr[:7]  // index 0~6
	// s5 := arr[:12] // index 12 (constant of type int) is out of boundscompiler
	fmt.Printf(" slice1 is %v ", s)
	fmt.Println()
	fmt.Printf(" slice2 is %v ", s2)
	fmt.Println()
	fmt.Printf(" slice3 is %v ", s3)
	fmt.Println()
	fmt.Printf(" slice4 is %v ", s4)
	fmt.Println()
}

out

 slice1 is [0 1 2 3 4 5 6 7 8 9] 
 slice2 is [0 1 2 3 4 5 6 7 8 9] 
 slice3 is [2 3 4 5 6 7 8 9] 
 slice4 is [0 1 2 3 4 5 6]
  • 字面量创建切片
func main() {
	// 创建数组，创建之初已有固定长度
	arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Printf(" arr is %v , type：%T", arr, arr)
	fmt.Println()

	// 字面量创建出来的不定长序列，没有推断长度
	s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Printf(" slice is %v , type：%T , len is %v , cap is %v ", s, s, len(s), cap(s))
	fmt.Println()

	// 基于创建的切片，追加一个元素10
	s = append(s, 10)
	fmt.Printf(" slice is %v , type：%T , len is %v , cap is %v ", s, s, len(s), cap(s))
	fmt.Println()
}

out

 arr is [0 1 2 3 4 5 6 7 8 9] , type：[10]int
 slice is [0 1 2 3 4 5 6 7 8 9] , type：[]int , len is 10 , cap is 10 
 slice is [0 1 2 3 4 5 6 7 8 9 10] , type：[]int , len is 11 , cap is 20
  • make
func main() {
	s := make([]int, 5, 5)
	fmt.Printf(" slice is %v ", s)
	fmt.Println()

	s = append(s, 1)
	fmt.Printf(" slice is %v ", s)
	fmt.Println()
}

out

 slice is [0 0 0 0 0] 
 slice is [0 0 0 0 0 1] 
指定容量的同时指定了长度，go中会给元素加上对应的默认值，再次append操作，会重新扩容，追加元素

常用make的姿势

func main() {
	s := make([]int, 0, 5)
	fmt.Printf(" slice is %v ", s)
	fmt.Println()

	s = append(s, 1)
	fmt.Printf(" slice is %v ", s)
	fmt.Println()
}

out

slice is []  
slice is [1] 
指定切片的容量，但是不指定长度，切片不会给元素加默认值，实际中切片可以按照预期正常追加，并且减少内存分配的次数
append与扩容

定义：内置函数，用来将元素追加到slice的尾部

每一次的append调用都会检查slice是否有足够的容量来添加新元素

  • 容量足够时append：创建一个新的slice，将新元素复制到末尾，并返回新的slice
  • 容量不够时append：创建一个新的拥有足够容量的新的底层数组，一般是2倍增长，然后将原slice复制到新数组中，再将新元素追加到数组末尾，再次创建新的slince引用，返回新的slice，此时append前后的底层数组已经发生了改变
func main() {
	arr := []int{1, 2}
	arr = append(arr, 3)
	fmt.Printf(" arr is %v", arr)
}

out

arr is [1 2 3]

append解析

func main() {
	arr := []int{1, 2}
	arr = appendTheory(arr, 3)
	fmt.Printf("arr is %v", arr)
}

func appendTheory(arr []int, value int) []int {
	var newArr []int
	newArrLen := len(arr) + 1
	if newArrLen <= cap(arr) {
		newArr = arr[:newArrLen]
	} else {
		newArrCap := newArrLen
		if newArrCap < 2*len(arr) {
			newArrCap = 2 * len(arr)
		}
		newArr = make([]int, newArrLen, newArrCap)
		copy(newArr, arr)
	}
	newArr[len(arr)] = value
	return newArr
}

out

arr is [1 2 3]

扩容解析

func main() {
	var arr []int
	for i := 0; i < 10; i++ {
		arr = append(arr, i)
		fmt.Printf("index is %d, cap is %d , len is %d \t %v \n", i, cap(arr), len(arr), arr)
	}
}

out

index is 0, cap is 1 , len is 1 	 [0] 
index is 1, cap is 2 , len is 2 	 [0 1] 
index is 2, cap is 4 , len is 3 	 [0 1 2] 
index is 3, cap is 4 , len is 4 	 [0 1 2 3] 
index is 4, cap is 8 , len is 5 	 [0 1 2 3 4] 
index is 5, cap is 8 , len is 6 	 [0 1 2 3 4 5] 
index is 6, cap is 8 , len is 7 	 [0 1 2 3 4 5 6] 
index is 7, cap is 8 , len is 8 	 [0 1 2 3 4 5 6 7] 
index is 8, cap is 16 , len is 9 	 [0 1 2 3 4 5 6 7 8] 
index is 9, cap is 16 , len is 10 	 [0 1 2 3 4 5 6 7 8 9]
切片传参

切片包含指向首元素的指针。虽然函数的传参是值传递，但是指针始终指向同一个数组，所以更改切片会直接影响函数外部的原始切片

func main() {
	arr := []int{1, 2}
	result := update(arr, 1, 3)
	fmt.Printf("arr is %v", result)
}

func update(arr []int, index, value int) []int {
	arr[index] = value
	return arr
}

out

arr is [1 3]
请叫我虎哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
go的make()的用法和参数含义
weixin_44063491的博客
05-08 5067
go的make()的用法和参数含义 golang分配内存有一个make函数，该函数第一个参数是类型，第二个参数是分配的空间，第三个参数是预留分配空间，前两个参数都很好理解，但对第三个参数不是很理解，例如a:=make([]int, 5, 10)， len(a)输出结果是5，cap(a)输出结果是10，然后我对a[4]进行赋值发现是可以得，但对a[5]进行赋值发现报错了，为了防止大家遇到同样的问题，做一下学习记录，代码如下。 package main import "fmt" func main(){
成功解决IndexError: index 0 is out of bounds for axis 1 with size 0
热门推荐
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
01-31 35万+
​ 成功解决IndexError: index 0 is out of bounds for axis 1 with size 0 目录 解决问题 解决思路 解决方法 解决问题 IndexError: index 0 is out of bounds for axis 1 with size 0 解决思路 索引错误：索引0超出了大小为0的轴1的范围。错误信息中提到了axis 1。轴1通常表示二维数组中的列。它说axis 1的size是0。意思是该数组没有任何列(列数为0)。但是你试图访
Go数组切片小知识解析
Millionmile的博客
09-09 1227
Go Lang中，数组并不难理解，但切片却不仅仅只是一个数组片段，你知道它隐藏的功能吗？切片和数组之前到底有什么关系呢？打基础小知识，实践出真理。
go_slice相关知识
qq_43510994的博客
11-26 255
go_slice相关知识 ①切片的左闭右开的引用 var s = [...]string{"a", "b", "c", "d", "e"} fmt.Printf("%T\f%q\f%d\n", s, s, len(s)) a := s[0:4] //i=0,j=4,a切片实际上引用了s数组中的从i到j-1索引位置的元素==左闭右开的引用 fmt.Printf("%T\f
typeof关键字简介
robbie1314的专栏
06-15 912
<br />今天用到typeof，看一下它的用法<br /><br />typeof关键字是C语言中的一个新扩展。只要可以接受typedef名称，Sun Studio C 编译器就可以接受带有typeof的结构，包括以下语法类别：声明 函数声明符中的参数类型链表和返回类型 类型定义 类型操作符s sizeof操作符 复合文字 typeof实参 <br />编译器接受带双下划线的关键字：__typeof和__typeof__。本文中的例子并没有遵循使用双下划线的惯例。从语句构成上看，typeof关键字后带圆括
Golang入门笔记（15）—— 数组和切片
wdw18668109050的博客
11-18 759
Golang入门笔记， 数组和切片
Golang学习：基础知识篇（二）—— 数组及切片
qq_44386537的博客
10-17 394
很久之前就想学Go语言了，但是一直有其他东西要学，因为我学的是Java嘛，所以后面学的东西一直是跟Java相关的。最近来到公司实习，需要用到Go语言，所以就趁着这个机会把Go学了。简单来说就是由Google公司的Robert Griesemer，Rob Pike和Ken Thompson设计的一种静态类型、编译型语言。它在2009年正式对外公开，目标是解决大规模软件工程中的问题。Go语言的语法简洁清晰，易于学习和使用，编译速度快，具有垃圾回收功能，并且拥有强大的标准库。
【Golang】五、基础篇 -- 数组和切片
m0_46537958的博客
04-01 1668
golang的数据，以及对数组的封装的结构体：切片
Golang学习：基础篇练习（二）—— 数组切片小实验
qq_44386537的博客
10-17 213
尽管切片背后的数组可能会随着元素的添加而增长，但是在添加元素之前，不能访问任何元素。
Golang算法问题之数组按指定规则排序的方法分析
09-21
本篇文章将探讨如何在Go语言中实现这样的功能，即对于一个多维数组（通常指二维数组），根据某一列或某些列的值来对其进行排序。 #### 核心概念解析 首先明确几个关键点： 1. **多维数组**：在Go语言中，数组是一种...
go代码-golang一维数组
07-14
在Golang中，一维数组是一种基础的数据结构，它存储相同类型的数据元素序列。这篇文章将深入探讨Go语言中一维数组的概念、声明、初始化、操作以及与其他数据结构的区别。 一、数组定义与初始化 在Go语言中，数组的...
Go语言：数组
qq_67615752的博客
09-14 1222
Go语言数组是切片学习的基础，这篇文章详细讲解数组的概念、声明、定义及使用。
2024-2030全球与中国硅胶婴儿用品市场现状及未来发展趋势 Sample-Li Jinpan.pdf
09-05
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。
用于非线性模型预测控制 (NMPC) 的并行优化工具包.7z
09-05
用于非线性模型预测控制 (NMPC) 的并行优化工具包.7z
Flow-Guided-Feature-Aggregation研究基于视频的目标检测FGFA框架.zip
最新发布
09-05
目标检测（Object Detection）是计算机视觉领域的一个核心问题，其主要任务是找出图像中所有感兴趣的目标（物体），并确定它们的类别和位置。以下是对目标检测的详细阐述： 一、基本概念 目标检测的任务是解决“在哪里？是什么？”的问题，即定位出图像中目标的位置并识别出目标的类别。由于各类物体具有不同的外观、形状和姿态，加上成像时光照、遮挡等因素的干扰，目标检测一直是计算机视觉领域最具挑战性的任务之一。 二、核心问题 目标检测涉及以下几个核心问题： 分类问题：判断图像中的目标属于哪个类别。 定位问题：确定目标在图像中的具体位置。 大小问题：目标可能具有不同的大小。 形状问题：目标可能具有不同的形状。 三、算法分类 基于深度学习的目标检测算法主要分为两大类： Two-stage算法：先进行区域生成（Region Proposal），生成有可能包含待检物体的预选框（Region Proposal），再通过卷积神经网络进行样本分类。常见的Two-stage算法包括R-CNN、Fast R-CNN、Faster R-CNN等。 One-stage算法：不用生成区域提议，直接在网络中提取特征来预测物体分类和位置。常见的One-stage算法包括YOLO系列（YOLOv1、YOLOv2、YOLOv3、YOLOv4、YOLOv5等）、SSD和RetinaNet等。 四、算法原理 以YOLO系列为例，YOLO将目标检测视为回归问题，将输入图像一次性划分为多个区域，直接在输出层预测边界框和类别概率。YOLO采用卷积网络来提取特征，使用全连接层来得到预测值。其网络结构通常包含多个卷积层和全连接层，通过卷积层提取图像特征，通过全连接层输出预测结果。 五、应用领域 目标检测技术已经广泛应用于各个领域，为人们的生活带来了极大的便利。以下是一些主要的应用领域： 安全监控：在商场、银行
习题集计算机原理习题集
09-05
【习题集】计算机原理习题集 计算机原理习题集 习题 一 1．微型计算机的发展经历了哪几个时代？每个时代有哪些主要特点？ 2．简述Pentium4 微处理器的处理能力。 3．冯·诺依曼计算机的结构特点是什么？ 4．典型微机有哪三大总线？它们传送的是什么信息？ 5．什么叫微处理器？什么叫微型计算机？什么叫微型计算机系统？这三者有什么区别和联系？ 6．微处理器内部一般由哪些部分组成？各部分的主要功能是什么？ 7．试用示意图说明内存单元的地址和内存单元的内容，二者有何联系和区别？ 8．高级语言、汇编语言、机器语言有何区别？各有何特点？ 9．评价微型计算机性能的主要指标有哪些？试举例说明现在市场主流机型微型计算机的性能参数。 10．现代微型计算机的主板通常由哪些部分组成？主板上的总线扩展插槽有何用途？ 习题 二 1．8086CPU从功能上分为哪两个工作部件？每个工作部件的功能、组成和特点分别是什么？ 2．8086CPU中有几个通用寄存器，有几个变址寄存器，有几个地址指针寄存器？它们中通常哪几个寄存器可作为地址寄存器使用？ 3．8086CPU的标志寄存器中有哪些标志位？它们的含义和作用是什么？
基于Spring Boot框架的尚融宝网络借贷平台.zip
09-05
基于Spring Boot框架的尚融宝网络借贷平台 项目介绍 尚融宝是一个网络借贷信息中介服务平台，致力为高成长人群提供专业的线上信贷及出借撮合服务。行业案例包括人人贷、拍拍贷等。 技术架构 前端 Node.js: Js运行环境 ES6: Js模块化版本 Axios: Ajax请求工具 Vue.js: 前端框架 ElementUI: 前端组件库 Vueelementadmin: 后台管理系统UI集成方案 NuxtJS: 前端服务器 后端 SpringBoot: 微服务开发框架 SpringCloud: 微服务组件库 SpringCloud Alibaba: 阿里微服务组件库 MyBatis Plus: 持久层框架 Swagger2: API接口文档生成工具 LogBack: 日志系统 alibabaeasyExcel: Excel读写框架 Redis: 缓存中间件 MySQL: 关系型数据库 SpringTask: 定时任务 RabbitMQ: 消息中间件 项目结构 前端 srbadmin: 管理平台 srbsi
基于改进YOLOv5检测脑瘤
09-05
mdpi的一篇文章，文章内容是关于结合NLNN和YOLOv5对脑肿瘤进行检测（是检测不是分类也不是分割）的一篇文章，文章里面说清楚了数据集的来源以及如何处理的，可以大致看一看，了解下相关背景以及如何用YOLO检测脑瘤的文章的写法，另外NLNN这个点也有些创意，有点像简化版自注意力机制，可以找找相关代码看看
Golang编程入门与教程
"这篇Golang教程涵盖了从基础到高级的各种主题，包括设置工作区、Go模块、基本语法、数据类型、控制结构、错误处理、并发等。教程旨在帮助初学者快速掌握这门语言，理解其设计哲学和核心特性。" 在深入探讨Golang...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值