在 Go 语言中，数组是一种固定长度的、存储相同类型元素的数据结构。

1.数组的基本概念

• 固定长度：数组的长度在定义时就确定，不能动态改变。
• 相同类型：数组中的所有元素必须是同一类型。
• 索引访问：通过索引（从 0 开始）访问数组元素。

2.数组的声明与初始化

在 Go 中，数组的声明和初始化有以下几种方式：

（1）声明后初始化

package main

import "fmt"

func main() {
    // 声明一个长度为 5 的整型数组
    var arr [5]int

    // 初始化数组元素
    arr[0] = 1
    arr[1] = 2
    arr[2] = 3
    arr[3] = 4
    arr[4] = 5

    // 打印数组
    fmt.Println("数组内容:", arr) // 输出: [1 2 3 4 5]
}

（2）声明时初始化

package main

import "fmt"

func main() {
    // 声明并初始化一个长度为 3 的字符串数组
    var arr = [3]string{"Go", "Python", "Java"}

    // 打印数组
    fmt.Println("数组内容:", arr) // 输出: [Go Python Java]
}

（3）省略长度初始化

package main

import "fmt"

func main() {
    // 声明并初始化数组，省略长度（由元素个数推断）
    arr := [...]int{10, 20, 30, 40}

    // 打印数组
    fmt.Println("数组内容:", arr) // 输出: [10 20 30 40]
}

3.数组的常见操作

（1）访问数组元素

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr := [3]int{100, 200, 300}

    // 访问数组元素
    fmt.Println("第一个元素:", arr[0]) // 输出: 100
    fmt.Println("第二个元素:", arr[1]) // 输出: 200
}

（2）修改数组元素

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr := [3]int{100, 200, 300}

    // 修改数组元素
    arr[0] = 500
    fmt.Println("修改后的数组:", arr) // 输出: [500 200 300]
}

（3）遍历数组

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr := [3]string{"Go", "Python", "Java"}

    // 使用 for 循环遍历数组
    for i := 0; i < len(arr); i++ {
        fmt.Printf("索引 %d: 值 %s\n", i, arr[i])
    }

    // 使用 range 关键字遍历数组
    for index, value := range arr {
        fmt.Printf("索引 %d: 值 %s\n", index, value)
    }
}

4.多维数组

Go 支持多维数组，例如二维数组。

（1）声明与初始化

package main

import "fmt"

func main() {
    // 声明并初始化一个 2x3 的二维数组
    var arr [2][3]int = [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }

    // 打印二维数组
    fmt.Println("二维数组内容:", arr) // 输出: [[1 2 3] [4 5 6]]
}

（2）访问与修改

package main

import "fmt"

func main() {
    // 声明并初始化一个 2x3 的二维数组
    arr := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }

    // 访问二维数组元素
    fmt.Println("第二行第三列:", arr[1][2]) // 输出: 6

    // 修改二维数组元素
    arr[0][1] = 99
    fmt.Println("修改后的二维数组:", arr) // 输出: [[1 99 3] [4 5 6]]
}

5.数组的长度与容量

数组的长度是固定的，可以通过 len 函数获取。

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr := [4]int{10, 20, 30, 40}

    // 获取数组长度
    length := len(arr)
    fmt.Println("数组长度:", length) // 输出: 4
}

6.数组的复制

在 Go 中，数组是值类型，赋值时会复制整个数组。

package main

import "fmt"

func main() {
    // 声明并初始化数组
    arr1 := [3]int{1, 2, 3}

    // 复制数组
    arr2 := arr1

    // 修改复制的数组
    arr2[0] = 100

    // 打印两个数组
    fmt.Println("原数组:", arr1) // 输出: [1 2 3]
    fmt.Println("复制数组:", arr2) // 输出: [100 2 3]
}

7.数组的局限性

• 固定长度：数组的长度不可改变，如果需要动态长度，可以使用 切片（Slice）。
• 值类型：数组赋值时会复制整个数组，可能导致性能问题。