定义

数组是一个由固定长度的元素类型相同组成的有序集合,一个数组由零或者多个元素组成。其中n是数组长度, elementType是数组元素类型。

  1. [n]elmentType

默认定义

数组的声明需要存储元素的长度值和存储数据的类型。其表示形式为 [n]Tn 表示数组中元素的长度值,T 代表每个元素的类型,数组的长度在声明的时候一定要给定,而数组一旦声明,其长度和类型都不能改变。

  1. var <数组名称> [<数组长度>]<元素类型>

eg:

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. var a [3]int //int array with length 3
  7. fmt.Println(a)
  8. }

var a[3]int 声明了一个长度为 3 的整型数组。数组中的所有元素都被自动赋值为数组类型的零值。在这种情况下,a 是一个整型数组,因此 a 的所有元素都被赋值为 0,即 int 型的零值。运行上述程序将输出 [0 0 0]

指定元素

初始化元素通过大括号包裹起来。

  1. var <数组名称> = [<数组长度>]<元素类型>{元素1,元素2,...}

eg:

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. a := [3]int{1, 2, 5}
  7. fmt.Println(a)
  8. }

在简略声明中,不需要将数组中所有的元素赋值。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. a := [3]int{10}
  7. fmt.Println(a)
  8. }

在上述程序中的第 8 行 a := [3]int{10} 声明一个长度为 3 的数组,但只提供了一个值 10,剩下的 2 个元素自动赋值为 0。这个程序将输出[10 0 0]

省略号

数组的长度可以使用省略号 ... 代替,这个并不是代表可以省略数组长度的声明,编译器会自动计算数组长度,它的长度值等于当前数组初始化元素的个数。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. a := [...]int{12, 78, 50} // ... makes the compiler determine the length
  7. fmt.Println(a)
  8. }

索引定义

  1. [<数组长度>]<元素类型>{索引1:元素1,索引2:元素2,…}
  1. const (
  2. FIRST int = iota
  3. SECOND
  4. THIRD
  5. FOURTH
  6. )
  7. func main() {
  8. arr :=[4]string{FIRST:"1",SECOND:"2",THIRD:"3",FOURTH:"4"}
  9. fmt.Println(arr)
  10. }
  11. //输出[1 2 3 4]

比较

同样类型的数组是可以相互赋值的,相同类型的数组必须是长度一样,并且每个元素的类型也一样的数组,因此数组的大小是类型的一部分。因此 [5]int[25]int 是不同类型。

  1. package main
  2. func main() {
  3. a := [3]int{5, 78, 8}
  4. var b [5]int
  5. b = a
  6. }

类型 [3]int 的变量赋给类型为 [5]int 的变量,这是不允许的,因此编译器将抛出错误 main.go:6: cannot use a (type [3]int) as type [5]int in assignment。

值类型

注意Go 中的数组是值类型而不是引用类型。

数组赋值

当数组赋值给一个新的变量时,该变量会得到一个原始数组的一个副本。如果对新变量进行更改,则不会影响原始数组。

  1. package main
  2. import "fmt"
  3. func main() {
  4. a := [...]string{"USA", "China", "India", "Germany", "France"}
  5. b := a
  6. b[0] = "Singapore"
  7. fmt.Println("a is ", a)
  8. fmt.Println("b is ", b)
  9. }

在上述程序的第 7 行,a 的副本被赋给 b。在第 8 行中,b 的第一个元素改为 Singapore。这不会在原始数组 a 中反映出来。该程序将 输出

  1. a is [USA China India Germany France]
  2. b is [Singapore China India Germany France]

函数参数传递

同样,当数组作为参数传递给函数时,它们是按值传递,而原始数组保持不变。

  1. package main
  2. import "fmt"
  3. func main() {
  4. array := [3]int{1:2}
  5. modify(array)
  6. fmt.Println("current list",array)
  7. }
  8. func modify(a [3]int){
  9. a[1] =3
  10. fmt.Println("modify list",a)
  11. }

执行上面程序结果

  1. modify list [0 3 0]
  2. current list [0 2 0]

传递数组的指针,可以实现修改数组值的

  1. package main
  2. import "fmt"
  3. func main() {
  4. array := [3]int{1:2}
  5. modify(&array)
  6. fmt.Println("current list",array)
  7. }
  8. func modify(a *[3]int){
  9. a[1] =3
  10. fmt.Println("modify list",*a)
  11. }

长度

通过将数组作为参数传递给 len 函数,可以得到数组的长度。

  1. package main
  2. import "fmt"
  3. func main() {
  4. a := [...]float64{67.7, 89.8, 21, 78}
  5. fmt.Println("length of a is",len(a))
  6. }

上面的程序输出为 length of a is 4

迭代

for 循环可用于遍历数组中的元素。

  1. package main
  2. import "fmt"
  3. func main() {
  4. a := [...]float64{67.7, 89.8, 21, 78}
  5. for i := 0; i < len(a); i++ { // looping from 0 to the length of the array
  6. fmt.Printf("%d th element of a is %.2f\n", i, a[i])
  7. }
  8. }

上面的程序使用 for 循环遍历数组中的元素,从索引 0length of the array - 1。这个程序运行后打印出,

  1. 0 th element of a is 67.70
  2. 1 th element of a is 89.80
  3. 2 th element of a is 21.00
  4. 3 th element of a is 78.00

Go 提供了一种更好、更简洁的方法,通过使用 for 循环的 range 方法来遍历数组。range 返回索引和该索引处的值。让我们使用 range 重写上面的代码。我们还可以获取数组中所有元素的总和。

  1. package main
  2. import "fmt"
  3. func main() {
  4. a := [...]float64{67.7, 89.8, 21, 78}
  5. sum := float64(0)
  6. for i, v := range a {//range returns both the index and value
  7. fmt.Printf("%d the element of a is %.2f\n", i, v)
  8. sum += v
  9. }
  10. fmt.Println("\nsum of all elements of a",sum)
  11. }

上述程序的第 8 行 for i, v := range a 利用的是 for 循环 range 方式。 它将返回索引和该索引处的值。 我们打印这些值,并计算数组 a 中所有元素的总和。 程序的 输出是

  1. 0 the element of a is 67.70
  2. 1 the element of a is 89.80
  3. 2 the element of a is 21.00
  4. 3 the element of a is 78.00
  5. sum of all elements of a 256.5

如果你只需要值并希望忽略索引,则可以通过用 _ 空白标识符替换索引来执行。

  1. for _, v := range a { // ignores index
  2. }

上面的 for 循环忽略索引,同样值也可以被忽略。

多维数组

到目前为止我们创建的数组都是一维的,Go 语言可以创建多维数组。

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func printarray(a [3][2]string) {
  6. for _, v1 := range a {
  7. for _, v2 := range v1 {
  8. fmt.Printf("%s ", v2)
  9. }
  10. fmt.Printf("\n")
  11. }
  12. }
  13. func main() {
  14. a := [3][2]string{
  15. {"lion", "tiger"},
  16. {"cat", "dog"},
  17. {"pigeon", "peacock"}, // this comma is necessary. The compiler will complain if you omit this comma
  18. }
  19. printarray(a)
  20. var b [3][2]string
  21. b[0][0] = "apple"
  22. b[0][1] = "samsung"
  23. b[1][0] = "microsoft"
  24. b[1][1] = "google"
  25. b[2][0] = "AT&T"
  26. b[2][1] = "T-Mobile"
  27. fmt.Printf("\n")
  28. printarray(b)
  29. }

在上述程序的第 17 行,用简略语法声明一个二维字符串数组 a 。20 行末尾的逗号是必需的。这是因为根据 Go 语言的规则自动插入分号。
另外一个二维数组 b 在 23 行声明,字符串通过每个索引一个一个添加。这是另一种初始化二维数组的方法。
第 7 行的 printarray 函数使用两个 range 循环来打印二维数组的内容。上述程序的 输出是

  1. lion tiger
  2. cat dog
  3. pigeon peacock
  4. apple samsung
  5. microsoft google
  6. AT&T T-Mobile

这就是数组,尽管数组看上去似乎足够灵活,但是它们具有固定长度的限制,不可能增加数组的长度。这就要用到 切片。

总结

1.数组是同一类型元素的集合,因此存储的数据类似必须是相同的
2.数组是有固定长度的,因此需要初始化数组时声明长度。
3.长度一样且每个元素的类型和值也一样的数组,才能相等。
4.数组属于值类型的,即将一个数组赋值给另外一个数组的时候,实际上就是将整个数组拷贝一份。