数组

数组是相同数据类型的一组长度固定的序列，类型可以是整形、字符串和浮点型等，数组元素可以通过索引来读取或者修改，索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推，最后一个元素的索引为数组长度减1。

示意图

数组声明

声明数组必须指定元素类型和数组长度，数组一旦声明，长度就不可变。

语法：

代码示例：

package main

import "fmt"

func main() {
 var intArr [5]int     // 声明一个长度为5的int类型数组
 var floatArr [5]float32    // 声明一个长度为5的float32类型数组
 var strArr [5]string    // 声明一个长度为5的string类型数组
 var boolArr [5]bool     // 声明一个长度为5的bool类型数组
 fmt.Println(intArr)
 fmt.Println(floatArr)
 fmt.Println(strArr)
 fmt.Println(boolArr)
}

由于只是声明了数组，并没有给数组初始化，所以输出均是打印的其类型相对应的默认值。

运行结果：

运行结果

数组初始化

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


...
var floatArr = [...]float32{1.0, 2.0, 3.0, 4.0, 5.0}

在数组声明之后，可使用索引的方式初始化数组中的元素，索引从0开始，最后一个元素索引为长度减1，不能超过最后一个元素的索引。

var strArr [5]string
strArr[0] = "A"
strArr[1] = "B"
strArr[2] = "C"
strArr[3] = "D"
strArr[4] = "E"

数组访问和遍历

[]

代码示例：

package main

import "fmt"

func main() {
 var intArr = [5]int{1, 2, 3, 4, 5}
 fmt.Println("第1个元素是：", intArr[0])
 fmt.Println("第2个元素是：", intArr[1])
 fmt.Println("第3个元素是：", intArr[2])
 fmt.Println("第4个元素是：", intArr[3])
 fmt.Println("第5个元素是：", intArr[4])
}

运行结果：

运行结果

for

代码示例：

package main

import "fmt"

func main() {
 var intArr = [5]int{1, 2, 3, 4, 5}
 for i := 0; i < len(intArr); i++ {
  fmt.Printf("第%d个元素是： %d \n", i + 1, intArr[i])
 }
}

使用for循环的方式遍历数组intArr，输出结果和上面索引方式一样。

for rangefor range
for range

代码示例：

package main

import "fmt"

func main() {
 var intArr = [5]int{1, 2, 3, 4, 5}
 for i, v := range intArr {
  fmt.Printf("第%d个元素是： %d \n", i + 1, v)
 }
}

使用该方法输出结果同上面一样。

前面所提到的都是一位数组，在go语言中，还有多维数组的概念，但是多维数组中使用到的最多的就是二维数组，所谓二维数组，其本质上可以看做是多个一位数组组成的。

示意图

arr[i][j]

二维数组声明和一维数组类似：

二维数组声明：

二维数组声明并初始化：

package main

import "fmt"

func main() {
 intArr := [3][4]int{
  {0, 1, 2, 3} ,    // 第一行
  {4, 5, 6, 7} ,    // 第二行
  {8, 9, 10, 11},   // 第三行
 }
 fmt.Println(intArr)
}

运行结果：

运行结果

arr[i][j]

代码示例：

package main

import "fmt"

func main() {
 intArr := [3][3]int{
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9},
 }
 fmt.Println("第1行第1列：", intArr[0][0])
 fmt.Println("第1行第2列：", intArr[0][1])
 fmt.Println("第1行第3列：", intArr[0][2])
 fmt.Println("第2行第1列：", intArr[1][0])
 fmt.Println("第2行第2列：", intArr[1][1])
 fmt.Println("第2行第3列：", intArr[1][2])
 fmt.Println("第3行第1列：", intArr[2][0])
 fmt.Println("第3行第2列：", intArr[2][1])
 fmt.Println("第3行第3列：", intArr[2][2])
}

运行结果：

运行结果

二维数组同样可以使用for循环进行遍历，一维数组使用一个for循环进行遍历，二维数组则使用两个for嵌套循环即可遍历。

代码示例：

package main

import "fmt"

func main() {
 intArr := [3][3]int{
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9},
 }
 for i := 0; i < len(intArr); i++ {   // len(intArr)获取到的是intArr的行数，intArr[i] 表示一个一维数组
  for j := 0; j < len(intArr[i]); j++ { // 按照一维数组的方式遍历即可
   fmt.Printf("第%d行第%d列：%d \n", i + 1, j + 1, intArr[i][j])
  }
 }
}

该方法使用两个for循环嵌套，外层循环控制二维数组的行数，len(intArr)获取到的是二维数组的总行数，内层循环控制二维数组的列数，len(intArr[i])获取到的是二维数组当前行的列数，运行结果和上面一样。

for range
package main

import "fmt"

func main() {
 intArr := [3][3]int{
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9},
 }
 for i, v := range intArr {  // 直接循环intArr，获取到的每一个v为一个一维数组
  for i1, v1 := range v {  // 按照一维数组的方式遍历即可
   fmt.Printf("第%d行第%d列：%d \n", i + 1, i1 + 1, v1)
  }
 }
}

运行结果同上。