Go 数组

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

示例1:

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

输出结果为

  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
  2. import "fmt"
  3. func main() {
  4. var a = new([5]int)
  5. test(a)
  6. fmt.Println(a, len(a))
  7. }
  8. func test(a *[5]int) {
  9. a[1] = 5
  10. }

输出结果:

  1. &[0 5 0 0 0] 5

示例3:

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

输出结果:

  1. [{0 User0} {8 User8}] 2
  2. [0x1f216130 0x1f216140] 2
上一篇: Go 数字解析
下一篇: Go 方法