最新Go-数组类型详解（声明、初始化、遍历、多维数组等）_strconv，2024年最新手握5家大厂offer

最新推荐文章于 2024-06-05 08:55:05 发布
最新推荐文章于 2024-06-05 08:55:05 发布
阅读量355 收藏 4
点赞数 3
分类专栏： 程序员 文章标签： go 学习 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84904639/article/details/138793049
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

注意：size可以使用…省略，推导

//初始化数组
var arr1 [3]int = [3]int{1,2,3}
var arr2 = [3]int{1:4,0:5,2:6}
arr3 := [...]int{7,8,9}
arr4 := [5]int{1:3,3:5}

遍历

for循环，下标

	n1 := len(arr1)
	for i:=0;i<n1;i++{
		fmt.Print(arr1[i]," ")
	}

for range

for key,value := range

	for _,n := range arr3{
		fmt.Print(n," ")
	}

_是匿名变量，可以看之前的文章了解变量和常量。

内存

src->cmd->compile->internal->types->type.go

// Array contains Type fields specific to array types.
type Array struct {
	Elem  *Type // element type
	Bound int64 // number of elements; <0 if unknown yet
}

// NewArray returns a new fixed-length array Type.
func NewArray(elem *Type, bound int64) *Type {
	if bound < 0 {
		Fatalf("NewArray: invalid bound %v", bound)
	}
	t := New(TARRAY)
	t.Extra = &Array{Elem: elem, Bound: bound}
	t.SetNotInHeap(elem.NotInHeap())
	return t
}

TARRAY是Array指针，以arr4为例，Go会生成一个连续空间，将第一个的地址给arr4第一个值*Type，长度给arr4的第二个值Bound。

	fmt.Printf("arr4:%v &arr4:%p &arr4[0]:%v &arr4[1]:%v\n",arr4, &arr4,&arr4[0], &arr4[1])

结果

arr4:[0 3 0 5 0] &arr4:0xc00000c450 &arr4[0]:0xc00000c450 &arr4[1]:0xc00000c458

以arr4为例，数组地址和第一个元素的地址一样，后面相差的为元素所占字节数，这里是int，所以差8。

数组作为参数

值传递

值传递，返回数组最大值下标

// 求数组最大值及下标
func getMax(arr [5]int)(int,int){
	maxValue := arr[0]
	index := 0
	for i,v := range arr{
		if v > maxValue {
			maxValue = v
			index = i
		}
	}
	return index, maxValue
}

注意：数组的长度也是数组类型的一部分，[2]int和[3]int是不一样的类型。如果你发现有人的代码写的[]int，可以传递任意长度的“数组”，那么，他说错了，他说的是切片而不是数组。

调用代码

index,value := getMax(arr4)

引用传递

//原地反转数组
func reverseArr(arr *[10]int){
	i:=0
	j:=len(*arr) - 1
	for{
		if i>=j{
			break
		}
		(*arr)[i],(*arr)[j] = (*arr)[j],(*arr)[i]
		i++
		j--
	}
}

调用代码

arr6 := [10]int{1,4,7,-9,99,2,5,78,22,33}
reverseArr(&arr6)

多维数组

以二维数组为例

二维数组：一维数组，每个元素是一维数组(首元素)地址，数组长度为列数

声明

var arr7 [2][3]int

声明并初始化

var arr8 = [...][2]int{{1,2},{2,3}}
	arr9 := [1][2]int{{5,6}}
	fmt.Println("arr7 arr8 arr9",arr7,arr8,arr9)

遍历

for

	for i:=0;i<len(arr8);i++{
		for j:=0;j<len(arr8[0]);j++{
			fmt.Print(arr8[i][j]," ")
		}
		fmt.Println()
	}

for range

	for _,row := range arr8{
		for _,val:= range row{
			fmt.Print(val," ")
		}
		fmt.Println()
	}

内存

大概应该是这样，是一维数组指针，没有记录Bound，因为一位数组有记录元素个数，就不必再记录一次了。由于不能.出Bound来，另外，也是刚入门Go，没有仔细阅读源代码，有大佬知道的话可以下方评论，或者等某天如果我发现错了，再回来改。

全部代码

package main

import "fmt"
// 创建26大小数组，存放A-Z
func alpha(){
	alpha := [26]byte{}
	var A byte = 'A'
	for i :=0;i<26;i++{
		alpha[i] = A + byte(i)
	}
	fmt.Printf("%c\n",alpha)
}
// 求数组最大值及下标
func getMax(arr [5]int)(int,int){
	maxValue := arr[0]
	index := 0
	for i,v := range arr{
		if v > maxValue {
			maxValue = v
			index = i
		}
	}
	return index, maxValue
}

//原地反转数组
func reverseArr(arr *[10]int){
	i:=0
	j:=len(*arr) - 1
	for{
		if i>=j{
			break
		}
		(*arr)[i],(*arr)[j] = (*arr)[j],(*arr)[i]
		i++
		j--
	}
}
func main() {
    //------------------声明数组------------------
    var arr [3]int

    //-----------------初始化数组-----------------
    var arr1 [3]int = [3]int{1,2,3}
	var arr2 = [3]int{1:4,0:5,2:6}
	arr3 := [...]int{7,8,9}
	arr4 := [5]int{1:3,3:5}
    fmt.Println("arr arr1 arr2 arr3 arr4:",arr,arr1,arr2,arr3,arr4)

	//-------------------遍历数组----------------
	n1 := len(arr1)
	fmt.Print("数组arr1:")
	for i:=0;i<n1;i++{
		fmt.Print(arr1[i]," ")
	}
	fmt.Println()

	fmt.Print("数组arr3:")
	for _,n := range arr3{
		fmt.Print(n," ")
	}
	fmt.Println()

	//--------------------内存----------------------
	fmt.Printf("arr4:%v &arr4:%p &arr4[0]:%v &arr4[1]:%v\n",arr4, &arr4,&arr4[0], &arr4[1])
	fmt.Println(&arr4[2])

	//-----------------数组做参数----------------------
	index,value := getMax(arr4)
    fmt.Println("arr4最大值的下标和值:",index,value)

	arr6 := [10]int{1,4,7,-9,99,2,5,78,22,33}
	reverseArr(&arr6)
    fmt.Println(arr6)

	//----------------------------二维数组----------------------------------
	//------------声明---------------
	var arr7 [2][3]int
	//-----------声明并初始化---------
	var arr8 = [...][2]int{{1,2},{2,3}}
	arr9 := [1][2]int{{5,6}}
	fmt.Println("arr7 arr8 arr9",arr7,arr8,arr9)

	//----------遍历-----------------
	fmt.Println("arr8:")
	for i:=0;i<len(arr8);i++{
		for j:=0;j<len(arr8[0]);j++{
			fmt.Print(arr8[i][j]," ")
		}
		fmt.Println()
	}

	fmt.Println("arr8:")
	for _,row := range arr8{
		for _,val:= range row{
			fmt.Print(val," ")
		}
		fmt.Println()
	}

	//------内存----------
	fmt.Printf("&arr8:%p &arr8[0]:%p &arr8[1]:%p &arr8[0][0]:%v &arr8[1][0]:%v",&arr8, &arr8[0], &arr8[1], &arr8[0][0], &arr8[1][0])


![img](https://img-blog.csdnimg.cn/img_convert/8fb380da182e5e6695981f5ee43e63e2.png)
![img](https://img-blog.csdnimg.cn/img_convert/43e35193fab90554c1816998ddc755b3.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

1], &arr8[0][0], &arr8[1][0])


[外链图片转存中...(img-zlEBCydm-1715568718748)]
[外链图片转存中...(img-myxMD8XB-1715568718749)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618658159)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84904639
关注
专栏目录
华为OD机试2024年E卷-数组拼接[100分]（ Java | Python3 | C++ | C语言 | JsNode | Go）实现100%通过率
算法算法算法！！！
08-26 260
现在有多组整数数组，需要将它们合并成一个新的数组。合并规则，从每个数组里按顺序取出固定长度的内容合并到新的数组中，取完的内容会删除掉，如果该行不足固定长度或者已经为空，则直接取出剩余部分的内容放到新的数组中，继续下一行。第一行是每次读取的固定长度，0
python调用golang 数组_Golang数据类型 数组(arry)
weixin_39762001的博客
12-24 351
前言前面学习了Go数据类型中的数字、字符串，下面看看Go中是否有Python中的list、dict等复合数据类型？需要注意的是在Go中数组是可变类型+值(拷贝)类型，而go中切片是引用类型；数组声明之后它里面的元素是可以被修改，如果把1个数组变量引用到1个新的变量，那么这个新的变量会重新拷贝一份旧数组的数组。Python中的list是可变+引用数据类型llist1 = ["A", "B", "C"...
Golang：数组定义、初始化
保暖透气大裤衩LeoLee的博客
09-15 5241
概述 golang中的数组与其他一些语言中的数组，不同点在于：golang中的数组是值类型，并非是基础数据类型，这一点很重要。 可以使用指针来对数组进行引用传递。 数组初始化之后，长度确定，每个元素的值为数组类型的默认值。 数组的地址与数组的第一个元素的地址一致。 除数组第一个元素外的其他元素的地址=前一个元素的地址+数组类型所占用的字节数，即数组中的元素地址是连续的。 所以当我们使用print打印数组的时候，数组的第一个元素地址即可代表该数组的地址，根据第一个元素的地址，可以得出之后每一个
Go-数组类型详解（声明、初始化、遍历、多维数组等）
热门推荐
关注网络安全、云原生安全
04-18 1万+
目录 上篇文章思考题 介绍 声明 声明并初始化 遍历 for循环，下标 for range 内存 数组作为参数 值传递 引用传递 多维数组 声明 声明并初始化 遍历 内存 参考 上篇文章思考题 Go-基本数据类型转换详解 结果 0 可接收错误 strNum := "123.hello" floatNum, er := strconv.ParseFloat(strNum,64) fmt.Println(floatNum,er) 结果 0 strcon.
数组类型
freedomai的专栏
07-21 546
一个数组（Array）就是一个可以容纳若干类型相同的元素的容器。这个容器的大小（即数组的长度）是固定的，且是体现在数组的类型字面量之中的。比如，我们声明了一个数组类型： type MyNumbers [3]int 注：类型声明语句由关键字type、类型名称和类型字面量组成。      所谓类型字面量，就是用于表示某个类型的字面表示（或称标记方法）。相对的，用于表示某个类型的值的字面表
go数据类型之数组
weixin_33852020的博客
09-11 215
2019独角兽企业重金招聘Python工程师标准>>> ...
Go语言程序的数组初始化
海岛Blog
08-20 7189
Go语言数组初始化是最基本的编程训练。通过这个例子可以知道多维数组的初始化，需要注意的是格式。 Go语言程序： // array project main.go package main import ( "fmt" ) const N int = 5 var a = [N + N]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} var b = [N][N]
go代码-golang二维数组IO
07-14
在Go语言中，二维数组是一种常见的数据结构，用于表示矩阵或表格形式的数据。它是由多个一维数组组成的数组，每个一维数组的长度可以相同也可以不同。本篇将重点讲解如何在Go中处理二维数组的输入输出（IO）操作。 ...
Go四神兽之数组
06-03 149
Array 数组 在 Go 语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可更改 基本语法 // 定义一个长度为3 元素类型为int的数组 list var list [3]int 数组定义 var 数组变量名 [元素数量]T 数组可以通过下标进行访问，下标是从 0 开始，最后一个元素下标是 len - 1 ，访问越界（下标在合法范围之内），则触发访问越界， 会...
Go语言学习4-数组类型
Huazie
04-01 857
Go语言数组类型
go语言，切片type数组,排序（看书自学
u011275093的博客
10-03 148
type table1 struct { Date string HallId string FilmId string Time string Name string } type HeroSlice1 []table1 func main() { var heroess HeroSlice1 heroes[0].Name = "123" heroess1 := table1{ Date: "123", HallId: "123", FilmId: "12.
Golang 数组
花木兰
05-06 235
数组特点 长度固定 类型相同 连续块，内存连续分布（容易计算索引） 内置类型或者结构类型 计算速度快 使用效率高 声明和初始化 声明时需要说明数据类型和数量 一旦声明后，类型和数量都不会变 如需要更长的数组，新建数组，原数组复制到新数组 数组初始化为对应类型的零值 声明数组 var array [5]int 声明并初始化数组 array:=[5] int{10,20,40,40,...
go语言数组如何初始化问题？ - 知乎
我们都在旅行
06-30 4392
数组是相同数据类型的一组长度固定的序列，类型可以是整形、字符串和浮点型等，数组元素可以通过索引来读取或者修改，索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推，最后一个元素的索引为数组长度减1。示意图声明数组必须指定元素类型和数组长度，数组一旦声明，长度就不可变。语法：代码示例： 由于只是声明了数组，并没有给数组初始化，所以输出均是打印的其类型相对应的默认值。运行结果：运行结果数组初始化时，可以在声明数组时使用大括号初始化，或者在数组声明完成之后使用索引对数组中指定位置的元素进行初始化，在
Go 语言中的数组：声明、初始化与应用
最新发布
栗筝i的博客
06-05 3248
在 Go 语言中，数组是一个具有固定长度和类型的数据项序列。数组的长度被定义为类型的一部分，因此[5]int和[10]int被视为不同的类型。数组在声明时会根据指定的顺序进行初始化，每个元素默认为其类型的零值。
go数组初始化
qq_31805127的博客
03-14 1454
1、数组初始化： `var ba = [5] float32{1000,2,3,7,50} //或者 balance:=[5]float32{1000,2,3,7,50} 2、如果数组长度不确定，可以使用…代替数组长度。 var ba = [...]float32{1000,2,3,7,50} //或者 balance := [...]float32{1000,2,3,7,50} 3、设置了数组的长度，还可以指定下标来初始化元素，其中初始化数组中{}的元素个数不能大于[]中的数字。 balance :=
Go 语言数组基础教程 - 数组的声明、初始化和使用方法
小万哥的博客
01-05 694
为了方便其他设备和平台的小伙伴观看往期文章：，关注后即可获取最新文章推送看完如果觉得有帮助，欢迎。
【Go语言】Go语言中的数组
Python、Golang、大数据
02-27 857
Go语言中的数组类型遍历一旦声明后长度就不能再变，这样就无法动态添加元素到数组中，如果要添加一个元素到数组中，需要将就数组的元素都拷贝过来，最后添加新的元素，如果数组的长度不能确定，我们设置了一个较多元素的数组，这就会影响到程序的性能。数组是值类型，将数组作为参数传递到函数时，传递的是数组的值拷贝，也即会先将数组拷贝到形参，函数体中引用的是形参而不是原来的数组，当我们在函数中对数组元素进行修改的时候，并不会影响原来数组的值，如果数组很大时，值拷贝也会影响到程序的性能。
【go基础】数组
Herbert
05-14 146
var 数组名 [数组大小]数据类型。
Go 数组 【Go语言圣经笔记】
Steve Wang's blog
07-20 219
数组 数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。数组的长度是固定的，因此在Go语言中很少直接使用数组。Go语言中有一种和和数组强相关的类型是Slice（切片），它是可以增长和收缩的动态序列，功能也更灵活，但是要理解slice工作原理的话需要先理解数组。 数组的每个元素可以通过索引下标来访问（这被称作随机存取），索引下标的范围是从0开始到数组长度减1的位置。内置的len函数将返回数组中元素的个数。 var a [3]int fmt.Println(a[0]) fmt.Pr
Go语言strings与strconv包深度解析及代码示例
"本文将深入探讨Go语言中的strings和strconv包，这两个包提供了丰富的字符串处理函数，适用于各种字符串操作。" 在Go语言中，`strings`和`strconv`是两个非常重要的标准库，它们分别用于处理基本的字符串操作和字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值