go语言第四章（数组和切片）

迈不过友情╰ 2024-03-23 11:07 32阅读 0赞

## go语言第四章（数组和切片） ##

首先没有编译器的可以通过这个网址进行敲代码：[Lightly][]

### 简介 ###

在 Go 语言中，数组是一种固定长度的数据结构，用于存储一组相同类型的元素。数组的长度在创建时就已经确定，不可变更。

### 数组 ###

#### 数组的声明和初始化 ####

在 Go 语言中，可以使用 var 关键字和数组类型来声明一个数组，然后使用 \{\} 来初始化该数组的值。例如：

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

上述代码定义了一个长度为 5 的整型数组，并将其初始化为 \{1, 2, 3, 4, 5\}。

也可以使用以下简化的方式来声明和初始化数组：

arr := [5]int{
        1, 2, 3, 4, 5}

这个代码示例与上述代码示例的效果是相同的，只是使用了短变量声明语法来声明并初始化数组。

如果想要让编译器自动计算数组长度，则可以使用 … 代替具体的长度数值，例如：

arr := [...]int{
        1, 2, 3, 4, 5}

上述代码会自动计算数组的长度为 5。

#### 数组的访问和遍历 ####

在 Go 语言中，可以使用下标来访问数组中的元素。数组的下标从 0 开始并逐个递增，最大值为数组长度减 1。例如：

arr := [5]int{
        1, 2, 3, 4, 5}
    fmt.Println(arr[0]) // 输出 1
    fmt.Println(arr[4]) // 输出 5

可以使用 for 循环来遍历数组中的所有元素。例如：

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

也可以使用 range 关键字来遍历数组，range 表达式返回数组的索引和对应的值。例如：

arr := [5]int{
        1, 2, 3, 4, 5}
    for index, value := range arr {
        
        fmt.Printf("索引：%d，值：%d\n", index, value)
    }

以上就是 Go 语言中数组的基本使用方法。需要注意的是，在编写代码时，要确保下标不越界，并注意数组长度和数据类型的匹配。

#### 例题 ####

##### 1. 计算并输出给定数组中所有元素的和 #####

package main
    
    import "fmt"
    
    func main() {
        
        arr := [5]int{
        1, 2, 3, 4, 5}
        sum := 0
        for i := 0; i < len(arr); i++ {
        
            sum += arr[i]
        }
        fmt.Printf("数组 %v 的元素之和为 %d\n", arr, sum)
    }

运行结果：  
![在这里插入图片描述][ed8f4eaf26634596b166aa208f93f62c.png]

##### 2. 在给定数组中查找指定的元素，并输出该元素的下标 #####

package main
    
    import "fmt"
    
    func main() {
        
        arr := [5]int{
        1, 2, 3, 4, 5}
        target := 3
        index := -1
        for i := 0; i < len(arr); i++ {
        
            if arr[i] == target {
        
                index = i
                break
            }
        }
        if index >= 0 {
        
            fmt.Printf("元素 %d 在数组 %v 中的下标为 %d\n", target, arr, index)
        } else {
        
            fmt.Printf("元素 %d 不在数组 %v 中\n", target, arr)
        }
    }

运行结果：  
![在这里插入图片描述][3f251f8328cb436b89cc729e843e30c1.png]

##### 3. 将给定数组中的元素倒序排列并输出结果 #####

package main
    
    import "fmt"
    
    func main() {
        
        arr := [5]int{
        1, 2, 3, 4, 5}
        for i := 0; i < len(arr)/2; i++ {
        
            j := len(arr) - i - 1
            arr[i], arr[j] = arr[j], arr[i]
        }
        fmt.Println("数组倒序后为：", arr)
    }

运行结果：  
![在这里插入图片描述][f9472ca6ead84837b8c4150f04384916.png]

### 切片 ###

#### 简介 ####

切片是一种动态长度的数据结构，可以根据需要自动扩展或缩小。在 Go 语言中，可以使用 `[]T` 表示一个元素类型为 T 的切片，并使用 `make` 函数来创建一个指定长度和容量的空切片。例如：

var slice []int
    slice = make([]int, 5)

上述代码定义了一个长度和容量均为 5 的整型切片。如果只指定长度而不指定容量，则切片的容量与长度相同。可以使用下标来访问切片中的元素，例如：

fmt.Println(slice[0]) // 输出 0
    fmt.Println(slice[4]) // 输出 0

同时，也可以使用 for 循环或者 range 关键字来遍历切片中的所有元素。

需要注意的是，如果将一个数组的部分元素赋值给一个切片，则该切片会引用原始数组的一部分元素。如果修改切片中的元素，则原始数组中对应的元素也会被修改。例如：

arr := [5]int{
        1, 2, 3, 4, 5}
    slice := arr[1:4]
    slice[0] = 10
    fmt.Println(arr)   // 输出 [1 10 3 4 5]
    fmt.Println(slice) // 输出 [10 3 4]

以上就是 Go 语言中数组和切片的基本概念。需要注意的是，在使用数组和切片时，要确保下标不越界，并注意数组长度和数据类型的匹配。

#### 例题 ####

##### 1. 编写一个函数，计算给定整型数组中所有元素的平均值。 #####

package main
    
    import "fmt"
    
    func average(arr [5]int) float64 {
        
        sum := 0
        for i := 0; i < len(arr); i++ {
        
            sum += arr[i]
        }
        return float64(sum) / float64(len(arr))
    }
    
    func main() {
        
        arr := [5]int{
        1, 2, 3, 4, 5}
        fmt.Printf("数组 %v 的平均值为 %.2f\n", arr, average(arr))
    }

运行结果：  
![在这里插入图片描述][2c19e70896184c3ea8098f0e03feb0f2.png]

##### 2. 编写一个函数，将给定整型切片中的所有元素相加并返回结果。 #####

package main
    
    import "fmt"
    
    func sum(slice []int) int {
        
        result := 0
        for i := 0; i < len(slice); i++ {
        
            result += slice[i]
        }
        return result
    }
    
    func main() {
        
        slice := []int{
        1, 2, 3, 4, 5}
        fmt.Printf("切片 %v 中所有元素的和为 %d\n", slice, sum(slice))
    }

运行结果：  
![在这里插入图片描述][f9334aeb378543d9bad4b9df44ff76ca.png]

##### 3. 编写一个函数，将给定整型切片中的所有奇数元素替换为其平方值，并输出修改后的结果。 #####

package main
    
    import "fmt"
    
    func squareOdd(slice []int) {
        
        for i := 0; i < len(slice); i++ {
        
            if slice[i]%2 == 1 {
        
                slice[i] *= slice[i]
            }
        }
    }
    
    func main() {
        
        slice := []int{
        1, 2, 3, 4, 5}
        fmt.Println("修改前：", slice)
        squareOdd(slice)
        fmt.Println("修改后：", slice)
    }

运行结果：  
![在这里插入图片描述][e546148f93884eea8becd95f1fdfbb6e.png]

[Lightly]: https://lightly.teamcode.com/
[ed8f4eaf26634596b166aa208f93f62c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/81106a77bd1f4a83acc4636564a06d66.png
[3f251f8328cb436b89cc729e843e30c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/127ea6f8c66347f389b524bcb9a51bbd.png
[f9472ca6ead84837b8c4150f04384916.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c1c66d47991f4ac18d55f66d5ae464f0.png
[2c19e70896184c3ea8098f0e03feb0f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/09877672a5464e5c88414073c449ef01.png
[f9334aeb378543d9bad4b9df44ff76ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/5fa27d28b6a641449924dc4bd04a908e.png
[e546148f93884eea8becd95f1fdfbb6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/58544bd4e77e4faabf15e7062accf392.png