开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 14 天，点击查看活动详情

1.数组简介

数组：是指一系列同一类型数据的集合。

同一个数组中存储的数据类型必须一样，比如不能既存整型也存浮点型。

2.数组基本操作

数组定义： var 数组名 [元素数量] 类型比如var Numbers [5] int就定义了一个长度为5的数组叫Numbers，里面的数据都是整型
赋值：赋值可以是在定义后直接赋值（即初始化），也可以定义完之后在后面进行赋值。下面演示初始化的几种方式
- 全部初始化：数组指定了多少个元素，就要赋给它多少个数值。比如var Numbers [5] int就指定了5个元素。要是全部初始化就要赋给它5个值。
```
func main() {
   var Numbers [5]int = [5] int{1,2,3,4,5} //下标是从0开始计算的
   fmt.Println(Numbers[0]) //打印出数组第一个元素
}
```
  在数组中我们可以通过下标来获取数组中的某一元素，但要注意下标是从0开始表示第一个元素，然后以此类推
  
  如果选择定义后直接赋值，那么等号左边的数组个数和类型可省略，可以直接写成Numbers := [5]int {}
- 部分初始化：在初始化时只对数组中部分元素进行初始化；
```
func main() {
   Numbers := [5]int{1, 2}
   fmt.Println(Numbers[0])
}
```
- 指定某个元素初始化：这种初始化格式采用下标:数值的方式
```
func main() {
   Numbers := [5]int{2: 5, 3: 6}
   fmt.Println(Numbers[3])
}
```
  把下标为2的元素赋值给它5这个数值，下标为3的元素赋值给它6这个数值
- 通过初始化确定数组长度：不指定数值长度，并用三个点代替，格式为[...]类型
```
func main() {
   Numbers := [...]int{7, 8, 5, 6}
   fmt.Println(len(Numbers))
}
```
  获取到的长度就是{}里元素个数，也是数组的长度

定义完之后赋值的几种方式：

逐个赋值

func main() {
   var Numbers [5]int
   Numbers[0] = 1
   Numbers[2] = 3
   fmt.Println(Numbers[0])
}

一次性赋值

func main() {
   var Numbers [5]int
   Numbers = [5]int{1, 2}
   fmt.Println(Numbers[0])
}

循环赋值

func main() {
   var Numbers [5]int
   for i := 0; i < len(Numbers); i++ {
      Numbers[i] = i + 2
   }
   fmt.Println(Numbers[0])
}

3.数组遍历

for ... len()

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

for ... range()：返回下标和值

func main() {
   Numbers := [5]int{1, 2, 3, 4, 5}
   for i, v := range Numbers {
      fmt.Println("下标:", i)
      fmt.Println("值:", v)
   }
}

如果不输出下标，则用下划线代替i

4.数组作为函数参数

格式：

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

调用：函数名(数组)
演示：在main函数里给一个数组赋值，在其他函数中实现这个数组的打印并在main函数中调用此函数
```
func main() {
   Numbers := [5]int{1, 2, 3, 4, 5}
   getPrint(Numbers)
}

func getPrint(n [5]int) {
   for i := 0; i < len(n); i++ {
      fmt.Println(n[i])
   }
}
```
注意：形参和实参必须保证数组的长度和元素类型一致；如果在其他函数中不采用指针的方式就修改原数组的数据，对原数组不造成影响。

5.数组值比较

目标：完成两个数组中元素的比较，判断其相同下标对应的元素是否完全一致。

自行完成函数功能写法：

func main() {
   num1 := [5]int{1, 2, 3, 4, 5}
   num2 := [5]int{2, 1, 3, 4, 5}
   b := compareValue(num1, num2)
   if b {
      fmt.Println("数组一致")
   } else {
      fmt.Println("数组不一致")
   }
}

func compareValue(n1 [5]int, n2 [5]int) bool {
   b := true
   //1. 判断两个数组的长度是否一致
   if len(n1) == len(n2) {
      //2. 判断值是否一致
      for i := 0; i < len(n1); i++ {
         if n1[i] == n2[i] {
            continue
         } else {
            b = false
            break
         }
      }
   } else {
      b = false //如果不相等返回一个bool类型值
   }
   return b
}

其他写法：在已知个数和类型相同情况下，可以直接用 '==' 或 '!='进行判断

func main() {
   num1 := [5]int{1, 2, 3, 4, 5}
   num2 := [5]int{2, 1, 3, 4, 5}
   fmt.Println(num1 == num2)
}

6.数组案例

从一个整数数组中取出最大的整数，最小整数，并且求总和，求平均值

func main() {
   nums := [5]int{3, 5, 7, 6, 1}
   max := nums[0]
   min := nums[0]
   var sum int
   for i := 0; i < len(nums); i++ {
      if nums[i] > max {
         max = nums[i]
      }
      if nums[i] < min {
         min = nums[i]
      }
      sum += nums[i]
   }
   fmt.Println("最大值:", max)
   fmt.Println("最小值:", min)
   fmt.Println("和:", sum)
   fmt.Printf("平均值:%.2f", float64(sum)/5)
}

输出一个字符串数组里最长字符串

func main() {
   nums := [5]string{"abc", "china", "chinese", "beijing", "tianjing"}
   max := nums[0]
   for i := 0; i < len(nums); i++ {
      if len(nums[i]) > len(max) {
         max = nums[i]
      }
   }
   fmt.Println(max)
}

7.二维数组

定义：var 数组名 [x] [y] 类型；第一个下标代表行，第二个下标代表列。var arr[2][3]int就表示定义了一个两行三列的整型数组。注意行和列都是从下标0开始的。
初始化：
- 全部初始化
```
func main() {
   arr := [2][3]int{{1, 2, 3}, {5, 6, 7}}
   fmt.Println(arr)
}
```
  这里我定义了一个两行三列的数组，对其全部初始化时，要在{}里面再加两个{}，表示两行，三个数据表示三列。
- 部分初始化
```
func main() {
   arr := [2][3]int{{1, 2}, {6}}
   fmt.Println(arr)
}
```
  这么写表示只给第一行的1,2列赋值，还有第二行第一列赋值。
- 指定元素初始化
```
func main() {
   arr := [2][3]int{1: {5, 6}}
   fmt.Println(arr)
}
```
  表示给第二行的1,2列元素赋值，1表示行下标
```
func main() {
   arr := [2][3]int{0: {1:6}}
   fmt.Println(arr)
}
```
  表示给第一行的第二个元素赋值
- 通过初始化确定二维数组的行数
  
  之前在一维数组时，我们可以用三个点代替[]里的数据，且数组长度可以根据初始化的值的个数来自动确定。但在二维数组中，列的数据个数是不能省略的，只能自动确定行数！

循环遍历打印二维数组

注意：len(二维数组名)：表示一个二维数组有几行； len(二维数组名[下标])：表示一个二维数组有几列。