Go语言数组

Go语言提供了数组类型的数据结构

数组是一组数据类型相同的元素序列，数据类型可以是基本数据类型，或者其它的自定义类型。

数组是有大小的，里面可以存放的元素个数是一定的。

数组里面的元素是有类型的，而且所有元素都是同一种类型。

如下图：

1 数组的声明

数组的声明语法如下：

copy
var 数组名  [长度]数组类型

var 后面跟 数组的名字，数组的长度和数组的类型 依次放后面，记住 [ ] 中要写上数组的大小

声明的数组，和变量一样，也是会有默认值的，数组里面的每个元素的值都是 相应类型的 默认值

比如 数值类型的，默认值是 0 ，数值类型的有int,float32,float64,unint等

比如 字符串类型的，默认值是空字符串，即 ""

示例：

下面定义一个 大小为 10 的，数组类型为 int 的数组 ( 即数组里面每个元素都是 int )

copy
func main() {
    var arr [10]int
    fmt.Println(arr)
}

//输出： [0 0 0 0 0 0 0 0 0 0]

从上面可以看到，声明了一个 数组大小为 10，类型是 int 的数组，数组里面的元素的默认值都为 0

2 初始化数组

在声明数组的同时，也可以给数组初始化，如下

示例：

copy
func main() {
    var arr = [5]int {1,2,3,4,5}
    fmt.Println(arr)
}

//输出：[1 2 3 4 5]

也可以使用 := 方式初始化，如下

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

//输出：[1 2 3 4 5]

也可以使用 ... 代替数组大小，如下

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

//输出：[1 2 3 4 5]

3 数组的访问

数组通过索引来访问对应的元素。数组的索引从 0 开始，所以如果一个数组的大小是10，那么索引的范围是 0到9， 即 [0 , 9]

如下示例：

copy
package main

import "fmt"

func main() {

    var arr [5]int
    fmt.Println(arr)    //输出：[0 0 0 0 0]

    //通过索引0，修改第一个元素的值
    arr[0] = 10
    fmt.Println(arr)    //输出：[10 0 0 0 0]

    //通过索引 4 ，修改最后一个元素的值
    arr[4] = 100
    fmt.Println(arr)    //输出：[10 0 0 0 100]

    for i := 0; i < 5;i++ {
        //循环访问数组中的元素
        fmt.Println(arr[i])
    }
}

//for循环输出如下：
10
0
0
0
100

4 数组的大小与遍历

Go语言中的数组大小是固定的，可以用 len()方法求出数组的大小。这在数组的遍历中非常有用

示例：

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

//输出：
1
2
3
4
5

二维数组

二维数组是多维数组中的一种，是最简单的多维数组，由于二维以上的数组用的不多，且和二维数组是类似。

所以只介绍一下二维数组。

2.1 二维数组定义

二维数组就是数组的数组。通俗点说就是，一维数组里面，每个元素还是一个一维数组

2.2 二维数组的声明

语法如下：

copy
var arr [x][y]类型

arr 是数组的名字， x 可以理解为一维数组的大小， 一维数组中每个元素也是一个数组，y 就可以理解为是这个数组的大小

下面定义一个 x = 2, y = 3 的二维数组

copy
package main
import "fmt"
func main() {
    // 定义一个二维数组，x = 2, y = 3
    var arr [2][3]int

    // 初始化数组
    arr = [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }

    // 打印二维数组
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            fmt.Printf("arr[%d][%d] = %d\n", i, j, arr[i][j])
        }
    }
}

示例如下：

copy
func main() {

   var arr[2][3]int
   arr[0][0] = 1
   arr[0][1] = 2
   arr[0][2] = 3

   arr[1][0] = 4
   arr[1][1] = 5
   arr[1][2] = 6

   for i := 0 ; i < 2;i++ {
      for j := 0 ; j < 3;j++ {
         fmt.Println(arr[i][j])
      }
   }
}

//输出如下：
1
2
3
4
5
6

小结

本小节对Go语言的数组里面的介绍。Go语言中用的最多的不是数组，而是下一节要讲的 切片(slice)

下面对本小节数组进行简单总结一下：

• 数组是一组数据类型相同的元素序列
• 数组是固定大小的，每个元素的类型都是相同的
• 可以使用下面几种方法定义数组
  1. var a[5]int
  2. var a = [5]int{1,2,3,4,5}
  3. a := [5]int{1,2,3,4,5}
  4. var a = [...]{1,2,3,4,5}
• 数组的索引从 0开始，假设数组的大小是 n , 那么数组的索引是 [0 , n- 1]
• 数组是通过索引进行元素的访问的
• 二维数组是数组的数组，可以理解为，一个一维的数组，里面每个元素还是一个数组
• 数组的大小可以用 SDK中的len()方法获取，如 n := len(arr), arr 是数组的名字