Go 数组

  • 数组是一个具有相同数据类型的元素组成的固定长度的有序集合。
  • 在Go语言中，数组是值类型，长度是类型的组成部分，也就是说”[10]int“和“[20]int”是完全不同的两种数组类型。
  • 同类型的两个数组支持”==”和”!=”比较，但是不能比较大小。
  • 数组作为参数时，函数内部不改变数组内部的值，除非是传入数组的指针。
  • 数组的指针：*[3]int
  • 指针数组：[2]*int

示例1：

  1. package main
  3. import "fmt"
  5. func main() {
  7.     // 这里我们创建了一个具有5个元素的整型数组
  8.     // 元素的数据类型和数组长度都是数组的一部分
  9.     // 默认情况下，数组元素都是零值
  10.     // 对于整数，零值就是0
  11.     var a [5]int
  12.     fmt.Println("emp:", a)
  14.     // 我们可以使用索引来设置数组元素的值，就像这样
  15.     // "array[index] = value"  或者使用索引来获取元素值，
  16.     // 就像这样"array[index]"
  17.     a[4] = 100
  18.     fmt.Println("set:", a)
  19.     fmt.Println("get:", a[4])
  21.     // 内置的len函数返回数组的长度
  22.     fmt.Println("len:", len(a))
  24.     // 这种方法可以同时定义和初始化一个数组
  25.     b := [5]int{1, 2, 3, 4, 5}
  26.     fmt.Println("dcl:", b)
  28.     // 数组都是一维的，但是你可以把数组的元素定义为一个数组
  29.     // 来获取多维数组结构
  30.     var twoD [2][3]int
  31.     for i := 0; i < 2; i++ {
  32.         for j := 0; j < 3; j++ {
  33.             twoD[i][j] = i + j
  34.         }
  35.     }
  36.     fmt.Println("2d: ", twoD)
  37. }

输出结果为

  1. emp: [0 0 0 0 0]
  2. set: [0 0 0 0 100]
  3. get: 100
  4. len: 5
  5. dcl: [1 2 3 4 5]
  6. 2d:  [[0 1 2] [1 2 3]]

拥有固定长度是数组的一个特点，但是这个特点有时候会带来很多不便，尤其在一个集合元素个数不固定的情况下。这个时候我们更多地使用切片。

示例2：

可以用new创建数组，并返回数组的指针

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var a = new([5]int)
  7.     test(a)
  8.     fmt.Println(a, len(a))
  9. }
  11. func test(a *[5]int) {
  12.     a[1] = 5
  13. }

输出结果：

  1. &[0 5 0 0 0] 5

示例3：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     a := [...]User{
  7.         {0, "User0"},
  8.         {8, "User8"},
  9.     }
  10.     b := [...]*User{
  11.         {0, "User0"},
  12.         {8, "User8"},
  13.     }
  14.     fmt.Println(a, len(a))
  15.     fmt.Println(b, len(b))
  17. }
  19. type User struct {
  20.     Id   int
  21.     Name string
  22. }

输出结果：

  1. [{0 User0} {8 User8}] 2
  2. [0x1f216130 0x1f216140] 2