Go语言还未入门就放弃之数组array

声明和初始化

  • var array [5]int 声明一个包含 5 个元素的整型数组,元素默认为零值
  • array := [5]int{10, 20, 30, 40, 50} 使用数组字面量声明数组
  • array := [...]int{10, 20, 30, 40, 50} 使用…替代数组的长度,让 Go 自动计算声明数组的长度
  • array := [5]int{1: 10, 2: 20} 声明一个有 5 个元素的数组,用具体值初始化索引为 1 和 2 的元素,其余元素为 0 值。
  • array := [5]*int{0: new(int), 1: new(int)} 声明包含 5 个元素的指向整数的数组,用整型指针初始化索引为 0 和 1 的数组元素

使用数组

  • array[2] = 8 修改索引为 2 的元素的值
  • *array[0] = 10 修改数组指针索引为0的元素
  • 把同样类型的一个数组赋值给另外一个数组,深度拷贝,改变一个数组的值,不会改变另外一个数组的值,注意,只有数组长度,类型相同才能赋值!

    1
    2
    3
    var array1 [5]string // 声明第一个包含 5 个元素的字符串数组
    array2 := [5]string{"Red", "Blue", "Green", "Yellow", "Pink"} // 声明第二个包含 5 个元素的字符串数组
    array1 = array2 // 把 array2 的值复制到 array1
  • 把一个指针数组赋值给另一个。注意:由于是指针,指向同样的地址,所以改变一个数组的值,同时会改变另外一个数组里面存放的值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var array1 [3]*string // 声明第一个包含 3 个元素的指向字符串的指针数组
    array2 := [3]*string{new(string), new(string), new(string)} // 声明第二个包含 3 个元素的指向字符串的指针数组,使用字符串指针初始化这个数组

    // 使用颜色为每个元素赋值
    *array2[0] = "Red"
    *array2[1] = "Blue"
    *array2[2] = "Green"

    array1 = array2 // 将 array2 复制给 array1

多维数组声明

  • var array [4][2]int // 声明一个二维整型数组,两个维度分别存储 4 个元素和 2 个元素
  • array := [4][2]int{ {10, 11}, {20, 21}, {30, 31}, {40, 41} } 使用数组字面量来声明并初始化一个二维整型数组
  • array := [4][2]int{1: {20, 21}, 3: {40, 41}} // 声明并初始化外层数组中索引为 1 个和 3 的元素
  • array := [4][2]int{1: {0: 20}, 3: {1: 41}} // 声明并初始化外层数组和内层数组的单个元素

多维数组访问

  • array[0][0] = 10 // 设置每个元素的整型值
  • 同样类型的多维数组赋值
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // 声明两个不同的二维整型数组
    var array1 [2][2]int
    var array2 [2][2]int
    // 为每个元素赋值
    array2[0][0] = 10
    array2[0][1] = 20
    array2[1][0] = 30
    array2[1][1] = 40
    // 将 array2 的值复制给 array1
    array1 = array2

函数间传递数组

  • 使用的是值传递,在函数里面改变数组的值不影响外面的数组。必须指定数组长度。

    1
    2
    3
    4
    // 函数 foo 接受一个 100 个整型值的数组
    func foo(array [100]int) {
    //......
    }
  • 使用指针在函数间传递大数组,只需要在栈上分配 8 字节的内存给指针就可以。如果改变指针指向的值,会改变共享的内存

    1
    2
    3
    4
    // 函数 foo 接受一个指向 100 万个整型值的数组的指针
    func foo(array *[1e6]int) {
    //......
    }

数组的遍历

  • 传统for循环

    1
    2
    3
    for i := 0; i<len(array1); i++ {
    fmt.Println(array1[i])
    }
  • range表达式

    1
    2
    3
    for i, value := range array2 {
    fmt.Println(i, value)
    }

其他

  • 除了上面提到的能使用 = 将数组内容拷贝给另外一个数组,若在数组长度相同,数组元素类型支持 ==,!= 操作符,那么数组也支持此操作,但如果数组类型不一样则不支持(需要长度和数据类型一致,否则编译不通过)。如:
    1
    2
    3
    4
    var arrRoom = [20]int{1: 100}
    var arrBed = [20]int{1: 100}

    fmt.Printf("%t", arrRoom == arrBed) //true
您的支持将鼓励我继续创作!
0%