Go_数组遍历、最大值、求和、多维数组
数组：
- 数组就是用来存储数据的容器，存储多个数据时数据类型要一致。如果想要保存任意类型数据，需要声明为接口类型数组
- 数组定义完成后，可以对数组进行赋值操作。数组是通过下标来进行操作的，下标的范围是从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)
}
}
s
数组值比较：
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)
}