Go 二维数组

前面几节接触的数组,里面的元素都是一个个独立的数字或字符串,通常称为 “一维数组”。如果一个数组里的每一个元素本身又是一个一维数组,那它就构成了 “二维数组”。

你可以把二维数组想象成一张像课程表、棋盘或 Excel 那样的表格,同时具有 “行” 和 “列” 两个维度。比如 [2][3]int 就代表一张 “2 行 3 列” 的整数表格:第 1 个中括号 [2] 表示有 2 行,第 2 个中括号 [3] 表示每一行有 3 列。

声明与初始化二维数组

在 Go 语言中,定义二维数组时需要在元素类型前面连续写两个中括号,分别用来指定 “行数” 和 “列数”。

语法:

// 只声明
var 数组名 [行数][列数]类型

// 指定行列初始化
数组名 := [行数][列数]类型{{第1行元素}, {第2行元素}}

// 自动推导行数
数组名 := [...][列数]类型{{第1行元素}, {第2行元素}}

说明:

初始化二维数组时,最外层的花括号 {} 里面嵌套了多个内层花括号。外层包含几个内层花括号,就代表有几行;每个内层花括号里包含几个元素,就代表这一行有几列。

和一维数组一样,如果我们只声明二维数组而不赋初始值,或者某一行填入的元素少于列数,没赋值的位置都会自动补上对应类型的默认零值。

示例 1:定义并初始化二维数组

package main

import "fmt"

func main() {
    a := [2][3]int{{1, 2, 3}, {4, 5}}    // 缺位自动补 0
    b := [...][2]int{
        {10, 20},
        {30, 40},
    }
    fmt.Println(a)
    fmt.Println(b)
}

运行结果如下。

[[1 2 3] [4 5 0]]
[[10 20] [30 40]]

分析:

在这个例子中,二维数组 a 指定了 2 行 3 列,但第 2 行只填了 4, 5 两个数字。空出来的第 3 列会自动补上默认值 0,所以最终输出为 [[1 2 3] [4 5 0]]。

二维数组 b 把每一行单独换行对齐来写,数据较多时看起来更像一张直观的表格。需要注意的是,把二维数组拆成多行书写时,每一行内层花括号末尾都必须加上英文逗号(,)。哪怕是最后一行 {30, 40}, 后面的逗号也不能漏掉,否则编译时会报错。

此外,数组 b 的第 1 个中括号写了 [...],编译器看到花括号里包含 2 行数据,就会自动推算为 [2][2]int 类型。在定义二维数组时,小伙伴们要记住:只有第 1 个中括号(行数)允许写成 [...],第 2 个中括号(列数)必须写明具体的数字。

// 正确方式
b := [...][2]int{{10, 20}, {30, 40}}

// 错误方式
c := [2][...]int{{10, 20}, {30, 40}}

为什么不能省略列数呢?因为二维数组的每一行本身就是一个定长的一维数组。编译器必须先知道 “每一行固定放几个元素”,才能确定每一行的具体类型,再根据数据算出总行数。

注意: Go 二维数组中每一行的列数都是固定的,填入的元素不能超过列数。如果需要让每一行拥有不同的长度或者动态增删行列,可以使用后面章节学习的二维切片。

访问与修改二维数组元素

想要读取或修改二维数组中某个位置的元素,我们需要同时指定 “行下标” 和 “列下标”。和一维数组一样,二维数组的行下标和列下标也都是从 0 开始编号的:第 1 行的行下标是 0,第 1 列的列下标也是 0,行列结构与下标对应关系如下图所示。

Go 二维数组的行列结构与下标对应关系

语法:

// 读取元素
变量名 := 数组名[行下标][列下标]

// 修改元素
数组名[行下标][列下标] = 新值

说明:

数组名[i][j] 的定位过程分为两步:先通过第 1 个下标 [i] 找到行下标为 i 的那一整行一维数组,再通过第 2 个下标 [j] 从这一行里取出列下标为 j 的元素。

示例 2:访问与修改二维数组

package main

import "fmt"

func main() {
    arr := [2][3]int{
        {10, 20, 30},
        {40, 50, 60},
    }
    fmt.Println(arr[0])       // 获取第 1 行的一维数组
    fmt.Println(arr[0][1])    // 获取第 1 行第 2 列元素
    fmt.Println(arr[1][2])    // 获取第 2 行第 3 列元素

    arr[0][1] = 200           // 修改第 1 行第 2 列的值
    fmt.Println(arr)
}

运行结果如下。

[10 20 30]
20
60
[[10 200 30] [40 50 60]]

分析:

在二维数组 arr 中,如果我们只写第 1 个下标 arr[0],取出来的就是第 1 行(行下标为 0)那一整行的一维数组 [10 20 30]。

再补上第 2 个下标 arr[0][1],就表示取出第 1 行第 2 列(行下标 0、列下标 1)的数字 20。同理,arr[1][2] 表示取出第 2 行第 3 列的数字 60,随后执行 arr[0][1] = 200 就把原来的 20 修改成了 200。

遍历二维数组

一维数组只需要一层循环就能从头到尾打印出来,而二维数组既有 “行” 又有 “列”,所以需要嵌套两层循环来遍历:外层循环负责一行一行往下走,内层循环负责把当前这一行里的每一列元素依次取出来。

下面我们来看看如何使用双层 for 循环和双层 for range 循环遍历二维数组。

示例 3:双层 for 循环遍历

package main

import "fmt"

func main() {
    arr := [2][3]int{
        {10, 20, 30},
        {40, 50, 60},
    }
    for i := 0; i < len(arr); i++ {
        for j := 0; j < len(arr[i]); j++ {
            fmt.Printf("%d ", arr[i][j])
        }
        fmt.Println()
    }
}

运行结果如下。

10 20 30
40 50 60

分析:

二维数组 arr 里一共有 6 个数字,为什么 len(arr) 算出来不是 6,而是 2 呢?

其实,二维数组 [2][3]int 的外层装的是 2 个 “行数组”。因此我们调用 len() 函数计算 len(arr) 时,得到的是总行数 2;而 arr[i] 表示当前这一行的一维数组 [3]int,所以 len(arr[i]) 算出来的就是这一行的总列数 3。

在内层循环中,fmt.Printf("%d ", arr[i][j]) 负责在同一行内打印每个数字并留出一个空格。等当前这一行的 3 个数字打印完毕后,外层循环末尾的 fmt.Println() 负责换到下一行,最终按 2 行 3 列的格式整齐输出。

如果我们在遍历时不需要用到行下标和列下标,使用双层 for range 循环写起来会更加简洁。下面我们通过计算二维数组所有元素的总和来演示一下。

示例 4:双层 for range 遍历求和

package main

import "fmt"

func main() {
    grid := [3][3]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }
    sum := 0
    for _, row := range grid {
        for _, val := range row {
            sum += val
        }
    }
    fmt.Printf("所有元素之和:%d\n", sum)
}

运行结果如下。

所有元素之和:45

分析:

外层 for _, row := range grid 每次取出一整行的一维数组 row,内层 for _, val := range row 再把这一行里的每个数字依次取出来累加到 sum 中,最终算出 1 到 9 的总和为 45。

需要注意的是,因为 Go 语言的数组属于值类型,循环变量 row 和 val 都只是复制出来的临时副本。如果在遍历过程中需要修改二维数组里的元素,不能直接修改 val,而应该保留下标变量并通过 grid[i][j] 直接赋值。

在实际开发中,一维数组和二维数组就已经足够应对绝大多数场景了。至于三维甚至更高维度的数组,语法虽然类似,但平时极少用到,小伙伴们简单了解一下即可。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号