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

数组：

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

特点:

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

索引：

概念：数组中数据的编号方式, 编号从0开始
作用：访问数组容器中的空间位置
数组在创建完毕后, 即使没有赋值, 也可以取出, 但取出的元素都是默认初始化值.

数组元素访问：

格式：数组名 [索引];

数组静态初始化：

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

定义格式:

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

数组赋值格式1：

var 数组名 [元素数量] 数据类型  = [元素数量] 数据类型 {数据1,数据2,数据3...}

数组赋值格式2：

数组名 := [元素数量] 数据类型 {数据1,数据2,数据3...}

全部初始化：

// 定义了5的长度，最多给5个数据，可以少不可以多，否则报越界异常
// var arr [5] int = [5] int {1,2,3,4,5}
var arr = [5] int {1,2,3,4,5}	// 可以简化成这样写

部分初始化：

// 定义了5的长度，最多给5个数据，可以少不可以多，否则报越界异常
arr := [5] int {1,2}

指定元素初始化：

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

演示：

func main() {
	Demo01()
}

func Demo01() {
	// 静态初始化格式1：
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	println("静态初始化格式1：", arr[1])

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

	// 部分初始化：
	arr3 := [5]int{0: 1, 1: 2}
	println("部分初始化：", arr3[1])

	// 静态初始化：
	arr4 := [...]int{1, 2, 3}
	println("动态初始化格式1：", arr4[1])

	// 静态初始化2：也可以先定义，后面再赋值
	var arr5 [5]int
	arr5[0] = 1
	arr5[1] = 2
	for i := 0; i < len(arr5); i++ {
		println(arr5[i])
	}
}

数组长度是类型的一部分，也就是说，元素类型相同，但数组长度不同的不属同一类型

func main() {
	var d1 [3]int
	var d2 [2]int
	d1 = d2 // 错误: cannot use d2 (type [2]int) as type [3]int in assignment
}

对于结构等复合类型，可省略元素初始化表达式中的类型标签

func main() {
	type user struct {
		name string
		age  byte
	}

	// 结构体类型的数组，最终是由编译器判断数组长度
	u := [...]user{	// ... 代表省略
		{"韩信", 20},
		{"露娜", 18},
	}
	fmt.Println(u)	// [{韩信 20} {露娜 18}]
}

在多维数组定义中，仅第一纬度允许使用...

func main() {
	a := [2][2]int{{1, 2}, {3, 4}}
	b := [...][2]int{{10, 20}, {30, 40}}
	c := [...][2][2]int{{{1, 2}, {3, 4}}, {{10, 20}, {30, 40}}}
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

内置函数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]))
}

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

func main() {
	var a, b [2]int
	fmt.Println(a == b) // true

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

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

索引越界异常：

func main() {
	Demo01()
}

func Demo01() {
	// 现在数组有5个元素，索引最大为4，如果去取索引5的值，就会报索引越界
	var arr [5]int = [5]int{1, 2, 3, 4, 5}
	println(arr[5])

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

数组遍历：

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

func Demo02() {
	arr := [5]int{1, 2, 3, 4, 5}
	for _, v := range arr {
		fmt.Println("Value：", v)
	}
}

数组作为函数参数：

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

格式：

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

// 调用
函数名(数组)

演示：

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

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

数组值比较：

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


func Demo04() 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() {
	Demo05()
}


func Demo05() {
	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]
		}
		// 循环判断数组的元素是否小于自定义的最小值，如果是就把值赋值给max，作为当前最小值
		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 Demo06() {
	arr := [...]string{"娜可露露", "雅典娜", "韩信", "李白"}
	max := arr[0]
	for i := 0; i < len(arr); i++ {
		if len(arr[i]) > len(max) {
			max = arr[i]
		}
	}
	fmt.Println(max)
}

二维数组：

概念：

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

全部初始化格式：

Var 变量名 [m] [n] int = [m] [n] int {{数据1,数据2,数据3},{数据1,数据2,数据3}}

部分初始化格式：

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

指定初始化格式：

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

说明：

var 变量名 [m][n] int
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

演示：

// 三种方式定义二维数组
func Demo08() {
	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}} 一维数组个数可以用... 但是一维数组长度不可以  会报错：array outside of array literal
	arr4 := [...][3]int{{1, 2, 3}, {4, 5, 6}, {1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr：", arr)
	fmt.Println("arr2：", arr2)
	fmt.Println("arr3：", arr3)
	fmt.Println("arr4：", arr4)
}

二维数组遍历：

理解是理解，用也会用，但是这个写法，看着真乱，go的语法真丑
len(二维数组名)：打印一维数组个数
len(二维数组[索引])：打印一维数组的长度

演示：

func Demo09() {
	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[0]); j++ { // 内循环是一维数组
			fmt.Print(arr[i][j])
		}
	}

	// for循环也可以，但是拿到的v是二维数组的个数，要用循环嵌套再遍历出一维数组的数据
	for _, v := range arr {
		fmt.Println(v)
		for _, data := range v {
			fmt.Println(data)
		}
	}
}