MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Go数组的使用与初始化

2023-09-034.3k 阅读

Go数组的定义与基本特性

在Go语言中，数组是一种固定长度的同类型元素的序列。它是Go语言提供的基本数据结构之一，理解数组的定义和特性对于编写高效的Go程序至关重要。

数组的定义语法

数组的定义语法如下：

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

例如，定义一个长度为5的整数数组：

var numbers [5]int

这里，numbers 是数组名，[5] 表示数组的长度为5，int 表示数组中元素的数据类型为整数。

数组的长度

数组的长度是其定义的一部分，一旦定义，长度就不能改变。例如：

package main

import "fmt"

func main() {
    var a [5]int
    fmt.Println(len(a))
}

上述代码中，len(a) 会返回5，即数组 a 的长度。

数组元素的类型

数组中的所有元素必须是相同的数据类型。例如，我们不能定义一个既包含整数又包含字符串的数组。如果需要存储不同类型的数据，可以考虑使用Go语言中的其他数据结构，如 interface{} 类型的切片（后续会详细介绍切片与数组的区别）。

数组的初始化方式

数组的初始化是给数组元素赋予初始值的过程。Go语言提供了多种数组初始化的方式。

初始化全部元素

可以在定义数组的同时初始化所有元素，例如：

var numbers [5]int = [5]int{1, 2, 3, 4, 5}

也可以省略数组长度，让Go语言根据初始化值的个数自动推断数组长度：

var numbers = [...]int{1, 2, 3, 4, 5}

这里的 ... 告诉编译器根据初始化值的个数来确定数组的长度。

部分元素初始化

可以只初始化数组的部分元素，未初始化的元素将使用其类型的零值。例如：

var numbers [5]int = [5]int{1, 2}

在这个例子中，numbers[0] 为1，numbers[1] 为2，而 numbers[2]、numbers[3] 和 numbers[4] 为0（因为 int 类型的零值是0）。

使用索引初始化特定元素

可以通过指定索引来初始化特定的元素，例如：

var numbers [5]int = [5]int{2: 100, 4: 200}

这里，numbers[2] 被初始化为100，numbers[4] 被初始化为200，其他元素为0。

访问和修改数组元素

数组元素可以通过索引进行访问和修改。数组的索引从0开始，到数组长度减1结束。

访问数组元素

访问数组元素的语法是 数组名[索引]。例如：

package main

import "fmt"

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

上述代码分别输出数组 numbers 的第一个和第三个元素，即1和3。

修改数组元素

修改数组元素同样通过索引来进行，例如：

package main

import "fmt"

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

在这个例子中，numbers[2] 的值从3被修改为100，然后输出修改后的值100。

多维数组

Go语言支持多维数组，多维数组本质上是数组的数组。

二维数组的定义与初始化

二维数组的定义语法如下：

var 数组名 [第一维长度][第二维长度]数据类型

例如，定义一个二维整数数组：

var matrix [3][4]int

初始化二维数组可以采用以下方式：

var matrix = [3][4]int{
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12},
}

这里，外层大括号包含三个内层大括号，每个内层大括号代表二维数组的一行。

访问和修改二维数组元素

访问和修改二维数组元素需要使用两个索引，例如：

package main

import "fmt"

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }
    fmt.Println(matrix[1][2])
    matrix[1][2] = 100
    fmt.Println(matrix[1][2])
}

上述代码先输出 matrix[1][2] 的值7，然后将其修改为100并再次输出。

多维数组的嵌套初始化

对于更高维度的数组，初始化方式类似。例如，三维数组的初始化：

var cube = [2][3][4]int{
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24},
    },
}

这里通过多层嵌套的大括号来初始化三维数组 cube。

数组作为函数参数

在Go语言中，数组可以作为函数的参数传递。

值传递

当数组作为函数参数传递时，默认是值传递。这意味着函数接收到的是数组的一个副本，对副本的修改不会影响原始数组。例如：

package main

import "fmt"

func modifyArray(arr [5]int) {
    arr[0] = 100
    fmt.Println("Inside function:", arr)
}

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    modifyArray(numbers)
    fmt.Println("Outside function:", numbers)
}

在上述代码中，modifyArray 函数修改了数组副本的第一个元素为100，但在 main 函数中输出的原始数组 numbers 的第一个元素仍然是1。

传递数组指针

如果希望在函数中修改原始数组，可以传递数组的指针。例如：

package main

import "fmt"

func modifyArray(arr *[5]int) {
    (*arr)[0] = 100
    fmt.Println("Inside function:", *arr)
}

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    modifyArray(&numbers)
    fmt.Println("Outside function:", numbers)
}

这里，modifyArray 函数接收一个指向数组的指针，通过解引用指针来修改原始数组的第一个元素。在 main 函数中输出的 numbers 的第一个元素变为100。

数组与切片的关系

切片（slice）是Go语言中一种灵活、功能强大的数据结构，它与数组密切相关。

切片是基于数组的动态视图

切片实际上是基于数组的一个动态视图，它提供了一种灵活的方式来操作数组的部分或全部元素。切片本身并不存储数据，而是引用一个底层数组。例如：

package main

import "fmt"

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

这里，slice 是基于数组 numbers 创建的切片，它引用了 numbers 从索引1到索引2（不包括索引3）的元素，输出为 [2 3]。

切片的动态特性

与数组不同，切片的长度是可以动态变化的。通过 append 函数可以向切片中添加元素，例如：

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4)
    fmt.Println(slice)
}

上述代码先定义了一个切片 slice，然后使用 append 函数向切片中添加了一个元素4，最后输出 [1 2 3 4]。

切片的容量

切片除了有长度（len）之外，还有容量（cap）。容量是指从切片的第一个元素开始到其底层数组末尾的元素个数。例如：

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    slice := numbers[1:3]
    fmt.Println(len(slice))
    fmt.Println(cap(slice))
}

这里，切片 slice 的长度为2（因为它包含 numbers[1] 和 numbers[2] 两个元素），容量为4（因为从 numbers[1] 到 numbers[4] 共有4个元素）。

数组的内存布局

了解数组在内存中的布局有助于我们更好地理解数组的性能和行为。

连续的内存存储

数组在内存中是连续存储的，这意味着数组的元素在内存中一个接一个地排列。例如，对于一个整数数组 [5]int，假设每个 int 类型占用4个字节，那么整个数组将占用20个字节的连续内存空间。这种连续存储的方式使得数组在遍历和访问元素时具有高效性，因为CPU可以利用缓存预取机制来提高访问速度。

多维数组的内存布局

多维数组在内存中也是连续存储的。以二维数组 [3][4]int 为例，它的内存布局是先存储第一行的4个元素，接着存储第二行的4个元素，最后存储第三行的4个元素。这种布局方式对于按行遍历二维数组是非常高效的，因为内存访问是连续的。例如：

package main

import "fmt"

func main() {
    matrix := [3][4]int{
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12},
    }
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            fmt.Printf("matrix[%d][%d] = %d, address: %p\n", i, j, matrix[i][j], &matrix[i][j])
        }
    }
}

上述代码输出二维数组每个元素的值及其内存地址，可以看到内存地址是连续递增的。

数组的遍历

遍历数组是常见的操作，Go语言提供了多种遍历数组的方式。

使用for循环遍历

最常见的方式是使用传统的 for 循环，例如：

package main

import "fmt"

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

这种方式通过索引来访问数组的每个元素，适用于需要精确控制遍历过程的情况。

使用for...range遍历

for...range 是Go语言特有的遍历方式，它可以同时获取元素的索引和值。例如：

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    for i, value := range numbers {
        fmt.Printf("Index: %d, Value: %d\n", i, value)
    }
}

for...range 遍历方式简洁明了，适用于不需要精确控制索引，只关心元素值的情况。如果只需要元素值，可以省略索引，例如：

package main

import "fmt"

func main() {
    numbers := [5]int{1, 2, 3, 4, 5}
    for _, value := range numbers {
        fmt.Println(value)
    }
}

这里的 _ 是Go语言中的空白标识符，用于忽略不需要的变量。

数组的排序

对数组进行排序是实际编程中经常遇到的需求。Go语言的标准库 sort 包提供了排序功能。

对整数数组排序

对于整数数组，可以使用 sort.Ints 函数进行排序。例如：

package main

import (
    "fmt"
    "sort"
)

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

这里需要注意的是，sort.Ints 函数接受的是一个 []int 类型的切片，所以我们使用 numbers[:] 将数组转换为切片。排序后，数组 numbers 的元素将按升序排列。

对其他类型数组排序

对于其他类型的数组，sort 包提供了通用的排序接口。例如，对字符串数组排序：

package main

import (
    "fmt"
    "sort"
)

func main() {
    words := [5]string{"banana", "apple", "cherry", "date", "fig"}
    sort.Strings(words[:])
    fmt.Println(words)
}

sort.Strings 函数将字符串数组按字典序进行排序。

数组与并发编程

在并发编程中，数组的使用需要特别注意数据竞争的问题。

并发访问数组

当多个协程并发访问和修改同一个数组时，如果没有适当的同步机制，就会发生数据竞争。例如：

package main

import (
    "fmt"
    "sync"
)

var numbers [5]int
var wg sync.WaitGroup

func increment(index int) {
    defer wg.Done()
    numbers[index]++
}

func main() {
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go increment(i)
    }
    wg.Wait()
    fmt.Println(numbers)
}

在上述代码中，多个协程同时对数组 numbers 的不同元素进行递增操作。由于没有同步机制，可能会导致数据竞争，最终输出的结果可能不是预期的 [1 1 1 1 1]。

使用同步机制避免数据竞争

为了避免数据竞争，可以使用Go语言提供的同步原语，如 sync.Mutex。例如：

package main

import (
    "fmt"
    "sync"
)

var numbers [5]int
var wg sync.WaitGroup
var mu sync.Mutex

func increment(index int) {
    defer wg.Done()
    mu.Lock()
    numbers[index]++
    mu.Unlock()
}

func main() {
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go increment(i)
    }
    wg.Wait()
    fmt.Println(numbers)
}

这里使用 sync.Mutex 来保护对数组 numbers 的访问，确保同一时间只有一个协程可以修改数组元素，从而避免了数据竞争。

数组的应用场景

数组在实际编程中有广泛的应用场景。

存储固定数量的数据

当需要存储固定数量的同类型数据时，数组是一个很好的选择。例如，存储一个班级学生的成绩，假设班级人数固定为50人，可以使用 [50]float64 数组来存储学生的成绩。

作为算法的数据结构

在一些算法中，数组被用作基本的数据结构。例如，排序算法（如冒泡排序、快速排序等）通常操作的是数组。此外，一些数值计算算法，如矩阵运算，也会使用多维数组来存储数据。

与其他数据结构结合使用

数组常常与其他数据结构结合使用。例如，切片底层基于数组实现，而结构体中也可以包含数组字段。例如：

package main

import "fmt"

type Point struct {
    coordinates [2]int
}

func main() {
    p := Point{[2]int{1, 2}}
    fmt.Println(p.coordinates)
}

这里定义了一个 Point 结构体，其中包含一个 [2]int 类型的数组字段 coordinates 来表示点的坐标。

通过以上对Go语言数组的详细介绍，希望读者对数组的使用、初始化以及相关特性有了更深入的理解，能够在实际编程中灵活运用数组来解决各种问题。在使用数组时，要充分考虑其固定长度、值传递等特性，结合具体的应用场景，选择最合适的数据结构和操作方式。同时，在并发编程中要注意避免数组的数据竞争问题，以确保程序的正确性和稳定性。