关于go:Go-容器之数组

在 Java 的外围库中，汇合框架堪称鼎鼎大名：Array、List、Set、Queue、HashMap 等等，轻易拎一个进去都值得开发者好好学习如何应用甚至是背地的设计源码（这类文章也挺多，大家上网轻易一搜）。

尽管 Go 语言没有如此丰盛的容器类型。

序列容器存储特定类型的数据元素。目前有 5 种序列容器的实现：

array
vector
deque
list
forward_list

这些序列容易能够用程序的形式保留数据，利用这些序列容易可能编写无效的代码，重复使用规范库的模块化。

Go 语言中的数组类型有点相似 C++ 中的数据，Go 的数组初始化定义后，在编译时就不会再变更。

定义数组的形式如下：

var a [10]int
b := [5]string {"H", "e", "l", "l", "o"}

[n]T 类型就示意含有 n 个类型为 T 的数组，本例中就是 a 变量示意含有 10 个 int 类型的整型数组；b 变量示意含有 5 个 string 类型的字符串数组。
数组的长度作为其类型的一部分，因而数组的长度是无奈调整的。

package main

import "fmt"

func main() {var a [10]int
    a[0] = 2022
    a[1] = 2023
    
    fmt.Println(a[0], a[1])
    fmt.Println(a)

    b := [5]string {"H", "e", "l", "l", "o"}
    
    fmt.Println(b)
}

运行后果如下：

Go 语言中，数组是一个长度固定的数据类型，用于存储一段具备雷同类型元素的序列（间断块）。在底层中，数组占用的内存是间断的，所以拜访起来速度十分块，还能够依据任意的索引找到相应的数据。

数组的内部结构有点相似下图，由一个个间断的内存空间组成：

var demo[5] int     // 数组 m demo: 蕴含 5 个整型元素

先申明一个名为 demo 的数组，可能存 5 个 int 类型的值，而后咱们给数组存入不同的值，尝试运行如下代码：

package main

import "fmt"

func main() {var demo [5]int
    demo[0] = 10
    demo[1] = 20
    demo[2] = 30
    demo[3] = 40
    demo[4] = 50

    fmt.Println(demo)
}

在终端运行后将会失去：[10 20 30 40 50]。能够看到，数组的索引是从 0 开始，如果数组长度为 5 的话，数组索引只会到 4。

如果一个一个给数组不同索引独自赋值的办法非常复杂，Go 提供了一种疾速创立数组并初始化的形式：应用数组字面量间接赋值，如：

arrayDemo := [5]int{10, 20, 30, 40, 50} // 申明长度为 5 的数组并用数值初始化每个元素

还能够用 ... 代替数组的长度，Go 语言会依据初始化数组元素的数量来确定数组的长度，如:

array := [...]int{10, 20, 30, 40, 50}   // 申明整型数组并用数值初始化，数组长度由初始化的数量决定

如果想指定具体索引地位的值，能够采纳：

array := [5]int{1: 10, 4: 100}

arrayDemo := [5]int{10, 20, 30, 40, 50}
arrayDemo[1] = 15   // 批改索引为 2 的元素的值，即把 20 改为 15

var array1 [5]string

array2 := [5]string{"Zhao", "Qian", "Sun", "Li", "Zhou"}

array1 = array2 // 复制 array2 给 array1

此时，array1 和 array2 两个数组的值齐全一样。

package main

import "fmt"

func main() {var array1 [5]string
    array2 := [5]string{"Zhao", "Qian", "Sun", "Li", "Zhou"}
    
    array1 = array2

    fmt.Println("array1 = array2 is:", array1 == array2)  // array1 = array2 is: true
}

当咱们把数据都保留在数组里后，比方考试分数。要求把保留在数组里的值全加起来，先算总和，而后算一下 平均分，能够应用如下的代码：

package main

import "fmt"

func main() {demo := [5]int{10, 20, 30, 40, 50}

    total := 0
    average := 0

    for i := 0; i < len(demo); i++ {total += demo[i]
    }
    average = total / len(demo)

    fmt.Println("Total:", total)
    fmt.Println("Average:", average)
}

// Total:  150
// Average:  30

如果应用 for..range 循环会产生什么呢？

package main

import "fmt"

func main() {demo := [5]int{10, 20, 30, 40, 50}

    total := 0
    average := 0

    for i, val := range demo {total += val}
    average = total / len(demo)

    fmt.Println("Total:", total)
    fmt.Println("Average:", average)
}
// 运行后失去：// # command-line-arguments
// arrays\main.go:11:6: i declared but not used

Go 编译器不容许您创立从未应用过的变量。因为咱们不在循环中应用 i，因而须要将其更改为下划线 _ (代表空)。

package main

import "fmt"

func main() {demo := [5]int{10, 20, 30, 40, 50}

    total := 0
    average := 0

    for _, val := range demo {total += val}
    average = total / len(demo)

    fmt.Println("Total:", total)
    fmt.Println("Average:", average)
}

单个 _（下划线）用于通知编译器咱们不应用它。（在这种状况下，咱们不须要迭代器变量）。

定义与操作根本相似与一维数组：

var array [4][3] int    // 申明一个二维数组，4 行 3 列

对二维数组进行操作：

package main

import "fmt"

func main() {var array1 [2][3]int

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

    fmt.Println(array2)
    fmt.Println(array2[1][2])
    array2[1][2] = 100 // 设置第二行第三列的值为 100
    fmt.Println(array2)

    array1 = array2 // 将 array2 的值复制给 array1
    fmt.Println(array1)

    fmt.Println("array1 = array2 is:", array1 == array2)
}

运行该代码，后果为：

[[1 2 3] [4 5 6]]
6
[[1 2 3] [4 5 100]]
[[1 2 3] [4 5 100]]
array1 = array2 is: true

总结一下，数组的注意事项：

If you don’t understand the data, you don’t understand the problem.

数组会占用间断的内存
数组有固定的类型和长度，还能够利用 ... 推断数组长度
拜访数组元素很不便，速度较快，复杂度为 O(1)

关于go:Go-容器之数组

1 序列容器

1.1 数组

1.2 数组的构造

1.3 数组定义

1.4 数组简洁创立形式

1.5 依据索引批改元素值

1.6 数组复制

1.7 数组运算

1.8 多维数组

总结