05- Go语言基础之数组

数组 是同一种数据类型的集合, 在Go 语言中, 数组从声明时就确定, 使用时可以修改数组成员, 但是 数组的大小无法变化,

基本语法:

  1. //  定义一个长度为3个元素 类型为int的数组
  2. var a [3]int

数组的定义

  1. var 数组变量名 [元素个数]T

比如: var a [5]int , 数组长度必须是常量, 并且长度是数组类型的一部分, 一旦定义, 长度不可改变. [5]int 与 [10]int 是不同类型.

  1. var a [3]int
  2. var b [4]int
  4. a = b  // a 和b 是不同的类型数据类型

数组可以通过下标进行访问, 下标是从0 开始, 最后一个元素的下标是: len-1, 访问越界, 则触发访问越界, 会 panic

数组的初始化

数组的初始化有很多方式.

方式一

初始化数组时 可以使用初始化列表来设置数组元素的值

  1. var array1 [3]int    // 数组会初始化为int类型的零值
  2. var numArray = [3]int{1,2}  // 使用指定的初始值完成初始化 
  3. var stringArray = [3]string{"上海", "北京", "杭州"}

方式二

按照上面的方法 每次都需要确保提供的初始值和数组长度一致, 一般情况下我们可以让编译器根据初始值的个数自行推断数组长度,

  1. var array1 [3]int    // 数组会初始化为int类型的零值
  2. var numArray = [...]int{1,2}  // 使用指定的初始值完成初始化 
  3. var stringArray = [...]string{"上海", "北京", "杭州"}

方式三

还可以使用指定索引值得方式来初始化数组,

  1. a := [...]int{1:1,3:5}

数组的遍历

数组的遍历有两种方法:

  • for 循环遍历
    1. var a = [...]string{"上海", "北京", "杭州"}
    2. for i:=0; i<len(a); i++ {
    3.   fmt.Println(a[i])
    4. }
  • for range 遍历
    1. for index, value :=range a {
    2.   fmt.Println(index, value)
    3. }

多维数组

Go 语言是支持多维数组的, (数组中嵌套数组)

二维数组的定义

  1. func main() {
  2.     a := [3][2]string{
  3.         {"北京", "上海"},
  4.         {"广州", "深圳"},
  5.         {"成都", "重庆"},
  6.     }
  7.     fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]
  8.     fmt.Println(a[2][1]) //支持索引取值:重庆
  9. }

二维数组的遍历

  2. func  main() {
  3.     a := [3][2]string{
  4.         {"北京", "上海"},
  5.         {"广州", "深圳"},
  6.         {"成都", "重庆"},
  7.     }
  8.     for _, v1 := range a {
  9.         for _, v2 := range v1 {
  10.             fmt.Printf("%s\t", v2)
  11.         }
  12.         fmt.Println()
  13.     }
  14. }

输出:

  1. 北京    上海    
  2. 广州    深圳    
  3. 成都    重庆

注意 多维数组只有第一次可以使用 ... 推导数组长度,

  1. //支持的写法
  2. a := [...][2]string{
  3.     {"北京", "上海"},
  4.     {"广州", "深圳"},
  5.     {"成都", "重庆"},
  6. }
  7. //不支持多维数组的内层使用...
  8. b := [3][...]string{
  9.     {"北京", "上海"},
  10.     {"广州", "深圳"},
  11.     {"成都", "重庆"},
  12. }

数组时值类型

数组时值类型., 赋值和传参会赋值整个数组, 因此改变副本的值, 不会改变本身的值

  1. func modifyArray(x [3]int) {
  2.     x[0] = 100
  3. }
  5. func modifyArray2(x [3][2]int) {
  6.     x[2][0] = 100
  7. }
  8. func main() {
  9.     a := [3]int{10, 20, 30}
  10.     modifyArray(a) //在modify中修改的是a的副本x
  11.     fmt.Println(a) //[10 20 30]
  12.     b := [3][2]int{
  13.         {1, 1},
  14.         {1, 1},
  15.         {1, 1},
  16.     }
  17.     modifyArray2(b) //在modify中修改的是b的副本x
  18.     fmt.Println(b)  //[[1 1] [1 1] [1 1]]
  19. }

注意

  • 数组支持 == != 操作符, 因为内存总是被初始化过的.
  • [n]*T 表示指针数组, *[n]T 表示数组的指针