Go 语言数组

242030

于 2023-06-22 22:24:42 发布

阅读量1.3k

点赞数

分类专栏： golang 文章标签： golang

本文链接：https://blog.csdn.net/qq_30614345/article/details/131345019

版权

golang 专栏收录该内容

68 篇文章 7 订阅

订阅专栏

1、Go 语言数组

Go 语言提供了数组类型的数据结构。

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符

串或者自定义类型。

相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ...,

numbers[99] 更加方便且易于扩展。

数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以

此类推。

1.1 声明数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式，例如以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

1.2 初始化数组

以下演示了数组初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

我们也可以通过字面量在声明数组的同时快速初始化数组：

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为1和3的元素初始化
balance := [5]float32{1:2.0,3:7.0}

初始化数组中 {} 中的元素个数不能大于 [] 中的数字。

如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

balance[4] = 50.0

以上实例读取了第五个元素。数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素

索引为 0，第二个索引为 1，以此类推。

1.3 访问数组元素

数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。例如：

var salary float32 = balance[9]

以上实例读取了数组 balance 第 10 个元素的值。

// 数组完整操作（声明、赋值、访问）
package main

import "fmt"

func main() {
	/* n 是一个长度为 10 的数组 */
	var n [10]int
	var i, j int
	/* 为数组 n 初始化元素 */
	for i = 0; i < 10; i++ {
		n[i] = i + 100 /* 设置元素为 i + 100 */
	}
	/* 输出每个数组元素的值 */
	/*
		Element[0] = 100
		Element[1] = 101
		Element[2] = 102
		Element[3] = 103
		Element[4] = 104
		Element[5] = 105
		Element[6] = 106
		Element[7] = 107
		Element[8] = 108
		Element[9] = 109
	*/
	for j = 0; j < 10; j++ {
		fmt.Printf("Element[%d] = %d\n", j, n[j])
	}
}

package main

import "fmt"

func main() {
	var i, j, k int
	// 声明数组的同时快速初始化数组
	balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出数组元素 */
	/*
		balance[0] = 1000.000000
		balance[1] = 2.000000
		balance[2] = 3.400000
		balance[3] = 7.000000
		balance[4] = 50.000000
	*/
	for i = 0; i < 5; i++ {
		fmt.Printf("balance[%d] = %f\n", i, balance[i])
	}
	balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出每个数组元素的值 */
	/*
		balance2[0] = 1000.000000
		balance2[1] = 2.000000
		balance2[2] = 3.400000
		balance2[3] = 7.000000
		balance2[4] = 50.000000
	*/
	for j = 0; j < 5; j++ {
		fmt.Printf("balance2[%d] = %f\n", j, balance2[j])
	}
	//  将索引为 1 和 3 的元素初始化
	/*
		balance3[0] = 0.000000
		balance3[1] = 2.000000
		balance3[2] = 0.000000
		balance3[3] = 7.000000
		balance3[4] = 0.000000
	*/
	balance3 := [5]float32{1: 2.0, 3: 7.0}
	for k = 0; k < 5; k++ {
		fmt.Printf("balance3[%d] = %f\n", k, balance3[k])
	}
}

2、Go 语言多维数组

Go 语言支持多维数组，以下为常用的多维数组声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

以下实例声明了三维的整型数组：

var threedim [5][10][4]int

2.1 二维数组

二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的。二维数组定义方式如下：

var arrayName [ x ][ y ] variable_type

variable_type 为 Go 语言的数据类型，arrayName 为数组名，二维数组可认为是一个表格，x 为行，y 为列。二

维数组中的元素可通过 a[ i ][ j ] 来访问。

package main

import "fmt"

func main() {
	// Step 1: 创建数组
	values := [][]int{}
	// Step 2: 使用 append() 函数向空的二维数组添加两行一维数组
	row1 := []int{1, 2, 3}
	row2 := []int{4, 5, 6}
	values = append(values, row1)
	values = append(values, row2)
	// Step 3: 显示两行数据
	// Row 1
	fmt.Println("Row 1")
	// [1 2 3]
	fmt.Println(values[0])
	// Row 2
	fmt.Println("Row 2")
	// [4 5 6]
	fmt.Println(values[1])
	// Step 4: 访问第一个元素
	// 第一个元素为：
	fmt.Println("第一个元素为：")
	// 1
	fmt.Println(values[0][0])
}

2.2 初始化二维数组

多维数组可通过大括号来初始值。以下实例为一个 3 行 4 列的二维数组：

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

注意：

以上代码中倒数第二行的}必须要有逗号，因为最后一行的}不能单独一行，也可以写成这样：
a := [3][4]int{  
{0, 1, 2, 3} ,   /*  第一行索引为 0 */
{4, 5, 6, 7} ,   /*  第二行索引为 1 */
{8, 9, 10, 11}}   /* 第三行索引为 2 */

// 初始化一个 2 行 2 列 的二维数组
package main

import "fmt"

func main() {
	// 创建二维数组
	sites := [2][2]string{}
	// 向二维数组添加元素
	sites[0][0] = "Google"
	sites[0][1] = "Baidu"
	sites[1][0] = "Taobao"
	sites[1][1] = "Weibo"
	// 显示结果
	// [[Google Baidu] [Taobao Weibo]]
	fmt.Println(sites)
}

2.3 访问二维数组

二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如：

val := a[2][3]
或
var value int = a[2][3]

以上实例访问了二维数组 val 第三行的第四个元素。

package main

import "fmt"

func main() {
	/* 数组 - 5 行 2 列*/
	// 多维数组初始化或赋值时需要注意 Go 语法规范，该写在一行就写在一行，一行一条语句
	var a = [5][2]int{{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}}
	var i, j int
	/* 输出数组元素 */
	/*
		a[0][0] = 0
		a[0][1] = 0
		a[1][0] = 1
		a[1][1] = 2
		a[2][0] = 2
		a[2][1] = 4
		a[3][0] = 3
		a[3][1] = 6
		a[4][0] = 4
		a[4][1] = 8
	*/
	for i = 0; i < 5; i++ {
		for j = 0; j < 2; j++ {
			fmt.Printf("a[%d][%d] = %d\n", i, j, a[i][j])
		}
	}
}

package main

import "fmt"

func main() {
	// 创建空的二维数组
	animals := [][]string{}
	// 创建三一维数组，各数组长度不同
	row1 := []string{"fish", "shark", "eel"}
	row2 := []string{"bird"}
	row3 := []string{"lizard", "salamander"}
	// 使用 append() 函数将一维数组添加到二维数组中
	animals = append(animals, row1)
	animals = append(animals, row2)
	animals = append(animals, row3)
	/*
		Row: 0
		[fish shark eel]
		Row: 1
		[bird]
		Row: 2
		[lizard salamander]
	*/
	// 循环输出
	for i := range animals {
		fmt.Printf("Row: %v\n", i)
		fmt.Println(animals[i])
	}
}

range方式循环二维数组：

package main

import "fmt"

func main() {
	arr := [...][]int{
		{1, 2, 3, 4},
		{10, 20, 30, 40},
	}
	/**
	1
	2
	3
	4
	10
	20
	30
	40
	*/
	for i := range arr {
		for j := range arr[i] {
			fmt.Println(arr[i][j])
		}
	}
}

package main

import (
	"fmt"
)

func main() {
	// 二维数组
	var value = [3][2]int{{1, 2}, {3, 4}, {5, 6}}
	// 遍历二维数组的其他方法，使用 range
	// 其实，这里的 i, j 表示行游标和列游标
	// v2 就是具体的每一个元素
	// v  就是每一行的所有元素
	/*
		value[0][0]=1    value[0][1]=2   [1 2]
		value[1][0]=3    value[1][1]=4   [3 4]
		value[2][0]=5    value[2][1]=6   [5 6]
	*/
	for i, v := range value {
		for j, v2 := range v {
			fmt.Printf("value[%v][%v]=%v \t ", i, j, v2)
		}
		fmt.Print(v)
		fmt.Println()
	}
}

3、Go 语言向函数传递数组

如果你想向函数传递数组参数，你需要在函数定义时，声明形参为数组，我们可以通过以下两种方式来声明：

// 方式一：形参设定数组大小
void myFunction(param [10]int){}

// 方式二：形参未设定数组大小
void myFunction(param []int){}

实例1：

// 实例中函数接收整型数组参数，另一个参数指定了数组元素的个数，并返回平均值
package main

import "fmt"

func main() {
	/* 数组长度为 5 */
	var balance = [5]int{1000, 2, 3, 17, 50}
	var avg float32
	/* 数组作为参数传递给函数 */
	avg = getAverage(balance, 5)
	/* 输出返回的平均值 */
	// 平均值为: 214.399994
	fmt.Printf("平均值为: %f ", avg)
}

func getAverage(arr [5]int, size int) float32 {
	var i, sum int
	var avg float32
	for i = 0; i < size; i++ {
		sum += arr[i]
	}
	avg = float32(sum) / float32(size)
	return avg
}

实例2：

package main

import (
	"fmt"
)

func main() {
	var array = []int{1, 2, 3, 4, 5}
	/* 未定义长度的数组只能传给不限制数组长度的函数 */
	setArray(array)
	/* 定义了长度的数组只能传给限制了相同数组长度的函数 */
	var array2 = [5]int{1, 2, 3, 4, 5}
	setArray2(array2)
}

func setArray(params []int) {
	// params array length of setArray is :  5
	fmt.Println("params array length of setArray is : ", len(params))
}

func setArray2(params [5]int) {
	// params array length of setArray2 is :  5
	fmt.Println("params array length of setArray2 is : ", len(params))
}

初始化数组长度后，元素可以不进行初始化，或者不进行全部初始化，但未进行数组大小初始化的数组初始化结果

元素大小就为多少。

3.1 多维数组传参

package main

import (
	"fmt"
)

func prt(arr [][]float32) {
	/*
	   -1
	   -3
	   -5
	*/
	for i := 0; i < 3; i++ {
		fmt.Println(arr[i][0])
	}
}

func main() {
	var arr = [][]float32{{-1, -2}, {-3, -4}, {-5}}
	prt(arr)
}

3.2 数组和切片的区别

// 声明数组
nums := [3]int{1,2,3}
// 声明切片
nums := []int{1,2,3}

没有所谓没有声明长度的数组存在。

Go 语言的数组是值，其长度是其类型的一部分，作为函数参数时，是值传递，函数中的修改对调用者不可见。

go 的数组作为函数参数传递的是副本，函数内修改数组并不改变原来的数组。

package main

import "fmt"

func change(nums [3]int) {
	nums[0] = 100
}

func main() {
	var nums = [3]int{1, 2, 3}
	//nums并未被改变
	change(nums)
	// 1
	fmt.Println(nums[0])
	return
}

Go 语言中对数组的处理，一般采用切片的方式，切片包含对底层数组内容的引用，作为函数参数时，类似于指

针传递，函数中的修改对调用者可见。

package main

import "fmt"

func change(nums []int) {
	nums[0] = 100
}

func main() {
	var nums = []int{1, 2, 3}
	//nums并未被改变
	change(nums)
	// 100
	fmt.Println(nums[0])
	return
}

3.3 引用传递

package main

import "fmt"

// Go 语言的数组是值，其长度是其类型的一部分，作为函数参数时，是值传递，函数中的修改对调用者不可见
func change1(nums [3]int) {
	nums[0] = 4
}

// 传递进来数组的内存地址，然后定义指针变量指向该地址，则会改变数组的值
func change2(nums *[3]int) {
	nums[0] = 5
}

// Go 语言中对数组的处理，一般采用切片的方式，切片包含对底层数组内容的引用，作为函数参数时，类似于指针传递，函数中的修改对调用者可见
func change3(nums []int) {
	nums[0] = 6
}

func main() {
	var nums1 = [3]int{1, 2, 3}
	var nums2 = []int{1, 2, 3}
	change1(nums1)
	//  [1 2 3]
	fmt.Println(nums1)
	change2(&nums1)
	//  [5 2 3]
	fmt.Println(nums1)
	change3(nums2)
	//  [6 2 3]
	fmt.Println(nums2)
}