数组：

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

特点:

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

索引：

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

数组静态初始化：

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

定义格式：

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

静态初始化格式1：

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}	// 可以简化成这样写

静态初始化格式2：

数组名 := [元素数量] 数据类型 {数据1,数据2,数据3...}
arr := [5]int{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]intfmt.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]intarr7[0] = 1arr7[1] = 2fmt.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() {var d1 [3]intvar d2 [2]intd1 = d2 // 错误: 无法将 'd2' (类型 [2]int) 用作类型 [3]int
}

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

func main() {arr := [...]int{1, 2, 3, 4, 5}NewArr := arrNewArr[0] = 100fmt.Println("arr：", arr) // arr： [1 2 3 4 5]fmt.Println("NewArr：", NewArr) //NewArr： [100 2 3 4 5]
}

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

type user struct {name stringage  byte
}func main() {// 结构体类型的数组，最终是由编译器判断数组长度，可以通过通过字段逐个赋值，也可以省略u := [...]user{{name: "娜可露露", age: 20}, {name: "不知火舞", age: 30}}u2 := [...]user{{"娜可露露", 20}, {"不知火舞", 30}}u3 := [2]user{{name: "哈哈", age: 99}}fmt.Println(u)  // [{娜可露露 20} {不知火舞 30}]fmt.Println(u2) //[{娜可露露 20} {不知火舞 30}]fmt.Println(u3) // [{哈哈 99} { 0}]
}

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

func main() {var a, b [2]intfmt.Printf("a的数据类型%T\t b的数据类型%T\n", a, b) // a的数据类型[2]int        b的数据类型[2]intfmt.Println("a == b", a == b) // a == b truec := [2]int{1, 2}d := [2]int{2, 3}fmt.Println("c == d", c == d) // falsevar e ,f [2] map[string]intfmt.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的索引。
• 解决方案： 将错误的索引修改为正确的索引范围即可！

数组遍历：

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

fori遍历

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

range遍历

func main() {arr := [5]int{1, 2, 3, 4, 5}for i, v := range arr {fmt.Println("索引：", i, "值：", v)}for _, i := range arr {fmt.Println(i)}
}

数组作为函数参数

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

格式：

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() {//arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}//Demo(arr)arr := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}Demo(arr)}func Demo(arr [...]int) {for i, v := range arr {fmt.Println("i=", i, "\t", "v=", v)}
}

数组值比较：

func main() {b := Demo()if b {fmt.Println("数据相同")} else {fmt.Println("数据不同")}
}func Demo() bool {b := truearr1 := [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 = falsebreak}}// 长度不同则返回内容结束循环} else {b = false}return b
}

数组小案例：

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

实现思路：

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

演示：

func main() {arr := [5]int{1, 2, 3, 4, 5}// 定义最大值、最小值、求和变量max := arr[0]min := arr[0]sum := 0for 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个一维数组，每个一维数组的长度是3arr := [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]))
}

二维数组遍历：

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)
}