Go_数组遍历、最大值、求和、多维数组

itzhuzhu.

已于 2023-02-13 00:53:39 修改

阅读量3.9k

点赞数 3

分类专栏： Golang 文章标签： golang 数组遍历最大值平均数求和多维数组

于 2022-01-26 16:06:37 首次发布

本文链接：https://blog.csdn.net/weixin_45477086/article/details/122696052

版权

Golang 专栏收录该内容

37 篇文章 2 订阅

订阅专栏

数组：

数组就是用来存储数据的容器，存储多个数据时数据类型要一致。如果想要保存任意类型数据，需要声明为接口类型数组
数组定义完成后，可以对数组进行赋值操作。数组是通过下标来进行操作的，下标的范围是从0开始到数组长度减1的位置

特点:

数组是一种引用数据类型
数组当中的多个数据，类型必须统一
数组的长度在程序运行期间不可改变

索引：

数组创建完成后，会在数组内开辟多个连续的空间，空间具体有多少是根据数组定义的长度决定的，而索引就是每个小空间的编号，编号是从0开始依次叠加，是用来获取数组中的数据的。数组在创建完毕后，即使没有赋值，也可以取出，但取出的元素都是默认初始化值，初始值根据数据类型而定。

数组静态初始化：

初始化：创建完后马上赋值的行为叫初始化
静态初始化：在创建数组时，直接将元素确定
动态初始化：go中只有静态，但是可以使用切片完成动态数组的操作

定义格式：

var 数组名 [元素数量] 数据类型 
var arr [5] int

静态初始化格式：

var 数组名 [元素数量] 数据类型  = [元素数量] 数据类型 {数据1,数据2,数据3...}
var arr [5] int = [5] int {0,1,2,3,4,5}
var arr = [5] int {0,1,2,3,4,5}	// 可以简化成这样写

部分初始化：

// 定义了5的长度，最多给5个数据，可以少不可以多，否则报越界异常，初始化是按照顺序的，写了两个，就等于索引0和1才有数据，其它都是默认0
arr := [5] int {1,2}

指定元素初始化：

数组名 := [元素数量] 数据类型 {索引1:数据,索引2:数据}
arr := [5] int {0:1,1:2}

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

数组名 := [...] 数据类型{数据1,数据2,数据3}
arr := [...] int {0:1,1:2}

访问数组元素：

数组名 [索引]
arr[0]

演示：

func main() {
	// 仅定义，未初始化
	var arr [5]int
	fmt.Println("arr的数据：", arr)

	// 静态初始化格式1：
	var arr2 [5]int = [5]int{1, 2, 3, 4, 5}
	fmt.Println("初始化格式1：", arr2, arr2[1])

	// 静态初始化格式2：
	arr3 := [5]int{1, 2, 3, 4, 5}
	fmt.Println("初始化格式2：", arr3[1])

	// 部分初始化：未初始化的数据自动填充默认值
	arr4 := [5]int{1, 2}
	fmt.Println("部分初始化：", arr4, arr[2])

	// 指定索引初始化：
	arr5 := [5]int{0: 1, 1: 2}
	fmt.Println("部分初始化：", arr5, arr5[0])

	// 类型推导：三个点就像是变参一样
	arr6 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println("推导类型：", arr6, arr6[1])

	// 初始化也可以先定义，再逐个赋值
	var arr7 [5]int
	arr7[0] = 1
	arr7[1] = 2
	fmt.Println("arr7：", arr7)
}

输出：

arr的数据： [0 0 0 0 0]
初始化格式1： [1 2 3 4 5] 2
初始化格式2： 2
部分初始化： [1 2 0 0 0] 0
部分初始化： [1 2 0 0 0] 1
推导类型： [1 2 3 4 5 6 7 8 9 10] 2
arr7： [1 2 0 0 0]

数组是值类型，传递后不会被修改原数组的数据

func main() {
	arr := [...]int{1, 2, 3, 4, 5}
	NewArr := arr // 赋值给一个新的数组
	NewArr[0] = 100
	fmt.Println("arr：", arr) // arr： [1 2 3 4 5]
	fmt.Println("NewArr：", NewArr) //NewArr： [100 2 3 4 5]
}

输出：

arr： [1 2 3 4 5]
NewArr： [100 2 3 4 5]

如果数组元素类型支持==、!=操作符，那么数组也支持比较操作

func main() {
	var a, b [2]int
	fmt.Printf("a的数据类型%T\t b的数据类型%T\n", a, b) // a的数据类型[2]int        b的数据类型[2]int

	fmt.Println("a == b", a == b) // a == b true

	c := [2]int{1, 2}
	d := [2]int{2, 3}
	fmt.Println("c == d", c == d) // false

	var e ,f [2] map[string]int
	fmt.Println(e==f) // 无效运算: e==f (在 [2]map[string]int 中未定义运算符 ==)
}

数组内存地址是数组中第一个元素的内存地址，各个元素之间的间隔是按照数组数据类型所占用的字节决定的，比如int64占用8个字节，那么数组中的每个元素内存地址之间间隔为8，因为int类型是占8个字节，所以每个变量的内存地址依次加8，而内存地址都是16进制计算的，所以结尾都是0和8（8+8=16 逢16进0）

func main() {
	arr := [4]int{1, 2, 3, 4}
	fmt.Printf("arrr的地址=%p\n  arr[0]地址=%p\n  arr[1]地址%p\n  arr[2]地址%p\n  arr[3]地址%p\n", &arr, &arr[0], &arr[1], &arr[2], &arr[3])
}

输出：

arrr的地址=0x1400012e000
arr[0]地址=0x1400012e000
arr[1]地址0x1400012e008
arr[2]地址0x1400012e010
arr[3]地址0x1400012e018

索引越界异常：

现在数组有5个元素，索引是0~4，如果去取索引5的值，就会报索引越界

func main() {
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	println(arr[5]) // 无效的 数组 索引 '5' (5 元素的数组超出界限)
}

出现原因：数组长度为5，索引范围是0~4，但是却访问了一个5的索引。
解决方案：将错误的索引修改为正确的索引范围即可！

数组遍历：

数组遍历：就是将数组中的每个元素分别获取出来，就是遍历。

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	for i := 0; i < len(arr); i++ {
		fmt.Println(arr[i])
	}

	for i, v := range arr {
		fmt.Println("索引：", i, "值：", v)
	}
}

数组作为函数参数

函数中修改数组中的值，不会影响到原数组

格式：

func 函数名 (数组){函数体}

// 调用
函数名(数组)

演示：

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	Demo(arr)
}

func Demo(arr [5]int) {
	for _, v := range arr {
		fmt.Println("Value：", v)
	}
}

数组值比较：

func main() {
	b := Demo()
	if b {
		fmt.Println("数据相同")
	} else {
		fmt.Println("数据不同")
	}
}


func Demo() bool {
	b := true
	arr1 := [5]int{1, 2, 3, 4, 5}
	//arr2 := [5]int{1, 2, 3, 4, 5}
	arr2 := [5]int{6, 7, 8, 9, 10}

	// 先判断长度，再判断数据
	if len(arr1) == len(arr2) {
		// 长度一样就判断数据
		for i := 0; i < len(arr1); i++ {
			// 如果一样的话就跳过本次循环，继续下一个数据对比
			if arr1[i] == arr2[i] {
				continue
				// 数据不同则返回内容结束循环
			} else {
				b = false
				break
			}
		}
		// 长度不同则返回内容结束循环
	} else {
		b = false
	}
	return b
}

数组小案例：

数组获取最大值、最小值、求和：

实现思路：

定义最大值/最小值变量，初始值为数组的0索引，数组循环的时候会依次比较，如果比最大值大/比最小值小，就赋值给最大值/最小值变量
求和：定义变量，循环相加即可
平均数不要直接除数组长度，要用len

演示：

func main() {
	arr := [5]int{1, 2, 3, 4, 5}

	// 定义最大值、最小值、求和变量
	max := arr[0]
	min := arr[0]
	sum := 0

	for i := 0; i < len(arr); i++ {
		// 判断数组的元素是否大于自定义的最大值，如果是就把值赋值给max，作为当前最大值
		if arr[i] > max {
			max = arr[i]
			// 判断数组的元素是否小于自定义的最小值，如果是就把值赋值给min，作为当前最小值
		} else if arr[i] < min {
			min = arr[i]
		}
		sum += arr[i]
	}
	fmt.Println("最大值：", max)
	fmt.Println("最小值：", min)
	fmt.Println("数组数据总和：", sum)
	fmt.Println("平均值：", sum/len(arr))
}

判断最长的元素

func main() {
	arr := [...]string{"娜可露露", "雅典娜", "韩信", "李白"}
	max := arr[0]
	for i := 0; i < len(arr); i++ {
		if len(arr[i]) > len(max) {
			max = arr[i]
		}
	}
	fmt.Println(max)
}

多维数组：

二维数组：

二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组

全部初始化格式：

// m：表示这个二维数组，可以存放多少个一维数组 n：表示每一个一维数组，可以存放多少个元素
var 变量名 [m] [n] int = [m] [n] int {{一维数组数据},{一维数组数据}}
变量名 := [m] [n] int {{一维数组数据},{一维数组数据}}// 简写

部分初始化格式：

// 没有被初始化的索引系统会赋上默认值
var 变量名 = [m] [n] int {{一维数组数据},{一维数组数据}}

指定初始化格式：

// 没有被初始化的索引系统会赋上默认值
var 变量名 = [m] [n] int {n{索引:数据},n{索引:数据}}

演示：

func main() {
	// arr是一个二维数组，里面存了2个一维数组，每个一维数组的长度是3
	arr := [2][3]int{{1, 2, 3}, {4, 5, 6}}
	arr2 := [2][3]int{{1, 2}, {4}}
	arr3 := [2][3]int{0: {0: 1, 1: 2, 2: 3}, 1: {0: 4, 1: 5, 2: 6}}
	//arr4 := [...][...]int{{1, 2, 3}, {4, 5, 6}, {1, 2, 3}, {4, 5, 6}} //  一维数组个数可以用... 但是一维数组长度不可以
	arr4 := [...][3]int{{1, 2, 3}, {4, 5, 6}, {1, 2, 3}, {4, 5, 6}}
	
	fmt.Println("arr：", arr, "\tarr[0]:", arr[0], "\tarr[1]：", arr[1])
	fmt.Println("arr2：", arr2, "\tarr2[0]:", arr2[0], "\tarr2[1]：", arr2[1])
	fmt.Println("arr3：", arr3, "\tarr3[0]:", arr3[0], "\tarr3[1]：", arr3[1])
	fmt.Println("arr4：", arr4, "\tarr4[0]:", arr4[0], "\tarr4[1]：", arr4[1])
}

输出：

arr： [[1 2 3] [4 5 6]]         arr[0]: [1 2 3]         arr[1]： [4 5 6]
arr2： [[1 2 0] [4 0 0]]        arr2[0]: [1 2 0]        arr2[1]： [4 0 0]
arr3： [[1 2 3] [4 5 6]]        arr3[0]: [1 2 3]        arr3[1]： [4 5 6]
arr4： [[1 2 3] [4 5 6] [1 2 3] [4 5 6]]        arr4[0]: [1 2 3]        arr4[1]： [4 5 6]

内置函数len和cap都返回第一纬度长度

func main() {
	a := [2]int{}
	b := [...][2]int{{10, 20}, {30, 40}, {50, 60}}
	println(len(a), cap(a))
	println(len(b), cap(b))
	println(len(b[1]), cap(b[1]))
}

输出：

2 2
3 3
2 2

二维数组遍历：

len(二维数组名)：打印一维数组个数
len(二维数组[索引])：打印一维数组的长度

演示：

func main() {
	arr := [2][3]int{{1, 2}, {4, 5, 6}}
	fmt.Println(len(arr))    // 一维数组的个数
	fmt.Println(len(arr[1])) // 一维数组的长度

	for i := 0; i < len(arr); i++ { // 外循环是二维数组
		for j := 0; j < len(arr[i]); j++ { // 内循环是一维数组
			fmt.Print(arr[i][j])
		}
	}

	for i, v := range arr {
		fmt.Println("数组：", i, "值：", v)
	}

	for _, v := range arr {
		fmt.Println(v)
		for _, data := range v {
			fmt.Println(data)
		}
	}
}

三维数组：

func main() {
	arr := [3][3][3]int{{}}
	fmt.Println(arr)
}

itzhuzhu.

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Go_数组遍历、最大值、求和、多维数组

数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。数组定义完成后，可以对数组进行赋值操作。数组是通过下标来进行操作的，下标的范围是从0开始到数组长度减1的位置。
复制链接

扫一扫

专栏目录