Go--数组

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、数组

• 和其他语言一样,Go语言中也有数组的概念, Go语言中的数组也是用于保存一组 相同类型 的数据
• 和其他语言一样,Go语言中的数组也分为 一维数组 和 多维数组

1.1、函数返回数组格式

func 函数名() (任意值泛指数组名 [数组长度]  类型) {
	var 数组名 [数组长度] 类型 = [数组长度]类型{值}
	return 数组名
}

eg：

func ArrInitTwo() (t [3]int) {    // t泛指数组，也可以任意定义为其他
	var arr [3]int = [3]int{8, 9}
	return arr
}

二、一维数组

2.1、格式

格式: var arr [元素个数]数据类型

• 和python语言中数组不同, Go语言中数组定义之后就 有默认的初始值
• 默认初始值就是保存数据类型的默认值(零值)

python的列表:
	li = [1, "老王", 22]  # 可以存放任意类型
	print(len(li))

因为go的数组在定义的时候就制定了类型所以 只能放同一类型的元素
go的数组:

	//定义一个一维数组
	var arr [3]int

	//打印数组
	fmt.Println(arr) // [0 0 0]

	// 定义数组
	var arrone [3]bool
	//打印数组
	fmt.Println(arrone)  // [0 0 0] 

2.2、初始化

2.2.1、 定义的同时完全初始化

代码如下（示例）：

var arr [3]int = [3]int{1, 3, 5}
fmt.Println(arr)   // [1 3 5] 

2.2.2、 定义的同时部分初始化

代码如下（示例）：

//定义的同时部分初始化

func ArrInitTwo() (t [3]int) {
	var arr [3]int = [3]int{8, 9}
	return arr  // [8 9 0] 
}

2.2.3、定义的同时指定元素初始化

代码如下（示例）：

// 定义的同时指定元素初始化
func ArrInitThree() (v [5]int) {
	var arr [5]int = [5]int{0: 8, 2: 9} // 指定位置赋值, 第一位的值是8，第三个值是9，剩余的值为0
	return arr                          // [8 0 9 0 0]
}

2.2.4、先定义再逐个初始化

代码如下（示例）：

// 先定义 再逐个初始化
func ArrInitFour() (v [3]int) {
	var arr [3]int
	arr[0] = 1
	arr[1] = 2
	arr[2] = 3
	return arr //[1 2 3]
}

2.2.1、先定义再一次性初始化

代码如下（示例）：

func ArrInitMonday() (v [3]int) {
	var arr [3]int
	arr = [3]int{2, 4, 6}
	return arr //[2 4 6]      
}

2.3、省略数组的元素个数

• […]会根据初始化元素个数自动确定数组长度

// -----------不指定元素个数

func ArrInitFive() (v [3]int) {
	var arr = [...]int{1, 3, 5}
	return arr //[1 3 5]
}

// 定义的同时指定元素初始化
func ArrInitSix() (v [7]int) {
	var arr = [...]int{6: 5} // 下标为6的元素值是5，所以这个数组长度是7
	return arr               // [0 0 0 0 0 0 5]
}

2.4、数组的访问

• 和python类似可以使用 数组名称[索引] 的方式

	arr := [...]int{1, 2, 3, 5, 8, 6}
	arr[1] = 666
	fmt.Println(arr) // [1 666 3 5 8 6]
	fmt.Println(arr[2]) // 3
	fmt.Println(arr[3]) // 5

2.5、遍历数组

• 遍历数组也是和python一样 使用for循环

	arr := [...]int{1, 2, 3, 5, 8, 6}

	//传统for循环遍历
	for i := 0; i < len(arr); i++ {
		fmt.Println(i, arr[i])
	}

	// for ...range遍历
	for i, v := range arr {
		fmt.Println(i, v)
	}

2.6、数组注意点

2.6.1、Go语言中 数组长度 也是 数据类型的一部分

	var arrone [3]int
	var arrtwo [3]int
	
	fmt.Println(arrone == arrtwo)  // true
	var arrthree [2]int
	fmt.Println(arrone == arrthree) // 类型不同不可以比较，因为数组的长度也是它本身的数据类型

2.6.2、如果元素类型支持==、!=操作时,那么数组也支持此操作

	arrmonday := [...]int{1, 3, 5}
	arrtuesday := [...]int{1, 3, 5}
	arrwednesday := [...]int{2, 4, 6}
	fmt.Println(arrmonday == arrtuesday)   // true
	fmt.Println(arrmonday == arrwednesday) // false

2.6.3、Go语言中的数组是值类型，赋值和传参时会复制整个数组

	arrJanuary := [...]int{1, 3, 4}
	arrFebruary := arrJanuary
	arrFebruary[0] = 666
	fmt.Println(arrJanuary) //[1 3 4]
	fmt.Println(arrFebruary)  // [666 3 4]  

二、二维数组

用法和java语言数组一样, 只是创建的格式不同
格式: [行数][列数]类型

func ArrJanuary() (v [2][3]int) {
	arr := [2][3]int{
		{1, 2, 3},
		{4, 5, 6}, // 注意 数组换行需要以逗号结尾
	}
	return arr  // [[1 2 3] [4 5 6]]  
}

• 创建多维数组时只允许第一维度使用…
• 格式: […][列数]类型

func ArrFebruary() (v [2][3]int) {
	// 创建一个两行三列的数组
	arr := [...][3]int{
		{1, 3, 5},
		{2, 4, 6},
	}
	return arr  // [[1 3 5] [2 4 6]] 
}