lesson10

数组

一维数组

• 声明：数组的大小必须是常量，不能是变量，比如下面的语法里的size必须是常量

  • 语法

    var variable_name [size] variable_type

  • 示例

    var num_list [10] int

• 初始化

  • 指定数组大小

    var float_num_list1 [5]float32 = [5]float32{1.0, 2.0, 3.0, 4.0, 5.0}
    var float_num_list2 = [5]float32{1.0, 2.0, 3.0, 4.0, 5.0}
    int_num_list := [3]int{1, 2, 3}
    for index, value := range float_num_list1 {
    	fmt.Println("[float_num_list1]index=", index, "value=", value)
    }
    
    for index, value := range float_num_list2 {
    	fmt.Println("[float_num_list2]index=", index, "value=", value)
    }
    
    for index, value := range int_num_list {
    	fmt.Println("[int_num_list]index=", index, "value=", value)
    }

  • 不显式指定数组大小，编译器根据赋的值自行推导

    var balance1 []int = [...]int{1,2} // 等价于[2]int{1,2}
    var balance2 = [...]int{1,2,3}
    balance3 := [...]int{1, 2}
    fmt.Println("balance1=", balance1)
    fmt.Println("balance2=", balance2)
    fmt.Println("balance3=", balance3)

  • 指定数组大小情况下，特殊的初始化方式

    balance := [5]int{1:10, 3:30} // 将数组下标为1和3的元素分别初始化为10和30
    fmt.Println(balance) // [0, 10, 0, 30, 0]

• 访问数组

  • 使用下标访问

    balance := [5]int{1:10, 3:30} // 将数组下标为1和3的元素分别初始化为10和30
    fmt.Println(balance)
    
    num := balance[1]
    fmt.Println("num=", num)
    for i:=0; i<5; i++ {
    	fmt.Printf("balance[%d]=%d\n", i, balance[i])
    }

  • range遍历

    var float_num_list1 [5]float32 = [5]float32{1.0, 2.0, 3.0, 4.0, 5.0}
    for index := range float_num_list1 {
        // index是数组下标
        fmt.Println("[float_num_list1]index=", index) 
    }
    
    for index, value := range float_num_list1 {
        // index是数组下标，value是对应的数组元素
    	fmt.Println("[float_num_list1]index=", index, "value=", value)
    }

  • 获取数组长度len(array)

    a := [...]int {1, 2, 3, 4, 5} 
    fmt.Println("array length=", len(a)) // array length=5

多维数组

• 声明：数组的大小必须是常量，不能是变量，比如下面语法里的size1，size2，...，sizeN必须是常量

  • 语法

    var variable_name [size1][size2]...[sizeN] variable_type

  • 示例

    var threeDimArray [2][3][4]int // 三维数组，大小是 2x3x4
    var twoDimArray [2][3] // 二维数组，大小是2x3

• 初始化

  • 初始化直接赋值

    array1 := [2][3]int {
        {0, 1, 2},
        {3, 4, 5}, // 如果花括号}在下一行，这里必须有逗号。如果花括号在这一行可以不用逗号
    }

  • 初始化默认值，后续再赋值

    array2 := [2][3]int{}
    array2[0][2] = 1
    array2[1][1] = 2
    fmt.Println("array2=", array2)

  • append赋值，只能对slice切片类型使用append，不能对数组使用append。参见后面lesson13里的slice类型介绍

    twoDimArray := [][]int{}
    row1 := []int{1,2,3}
    row2 := []int{4,5}
    twoDimArray = append(twoDimArray, row1)
    fmt.Println("twoDimArray=", twoDimArray)
    
    twoDimArray = append(twoDimArray, row2)
    fmt.Println("twoDimArray=", twoDimArray)

• 访问二维数组

  • 数组下标遍历具体的元素

    array1 := [2][3]int {
        {0, 1, 2},
        {3, 4, 5}}
    for i:=0; i<2; i++ {
        for j:=0; j<3; j++ {
            fmt.Printf("array1[%d][%d]=%d ", i, j, array1[i][j])
        }
        fmt.Println()
    }

  • 数组下标遍历某行元素

    package main
    
    import "fmt"
    import "reflect"
    
    func main() {
        array := [2][3]int{{1, 2, 3}, {4, 5, 6}}
        for index := range array {
            // array[index]类型是一维数组
            fmt.Println(reflect.TypeOf(array[index])) 
            fmt.Printf("index=%d, value=%v\n", index, array[index])
        }
    }

  • range遍历

    twoDimArray := [2][3]int {
        {0, 1, 2},
        {3, 4, 5}}
    for index := range twoDimArray {
        fmt.Printf("row %d is ", index) //index的值是0,1，表示二维数组的第1行和第2行
        fmt.Println(twoDimArray[index]) //twoDimArray[index]类型就是一维数组
    }
     for row_index, row_value := range twoDimArray {
        for col_index, col_value := range row_value {
            fmt.Printf("twoDimArray[%d][%d]=%d ", row_index, col_index, col_value)
        }
        fmt.Println()
    }

• 注意事项

  • slice类型的每一维度的大小可以不相同，比如下例里的第0行size是3，第1行size是2。如果直接访问twoDimArray[2][2]会报错。slice类型的介绍参见lesson13

    twoDimArray := [][]int{}
    row1 := []int{1,2,3}
    row2 := []int{4,5}
    twoDimArray = append(twoDimArray, row1)
    fmt.Println("twoDimArray=", twoDimArray)
    
    twoDimArray = append(twoDimArray, row2)
    fmt.Println("twoDimArray=", twoDimArray)

• 数组作为函数参数进行传递

  • 如果数组作为函数参数，实参和形参的定义必须相同，要么都是长度相同的数组，要么都是slice类型。如果实参和形参的类型一个是数组，一个是slice，或者实参和形参都是数组但是长度不一致都会编译报错

    package main
    
    import "fmt"
    import "reflect"
    
    func sum(array [5]int, size int) int{
        sum := 0
        for i:=0; i<size; i++ {
            sum += array[i]
        }
        return sum
    }
    
    func sumSlice(array []int, size int) int{
        sum := 0
        for i:=0; i<size; i++ {
            sum += array[i]
        }
        return sum
    }
    
    func main() {
        a := [5]int {1, 2, 3, 4, 5} // a := [...]int{1, 2, 3, 4, 5}也可以去调用sum，编译器会自动推导出a的长度5
        fmt.Println("type of a:", reflect.TypeOf(a)) // type of a: [5]int
        ans := sum(a, 5)
        fmt.Println("ans=", ans)
        
        b := []int{1, 2, 3, 4, 5}
        ans2 := sumSlice(b, 5)
        fmt.Println("ans2=", ans2)
        
        array := [...]int {1}
        fmt.Println("type of array:", reflect.TypeOf(array)) // type of array: [1]int，是一个数组类型
        fmt.Println("array=", array)
    }

  • 值传递和引用传递

    • Go语言里只有值传递，没有引用传递。可以参考进阶篇文章Go有引用传递么?。

    • 如果数组作为函数参数，在函数体内不能改变外部实参的值。如果使用数组作为形参，想修改实参的值，那就要传指向数组的指针

    • 如果slice作为函数参数，在函数体内可以改变外部实参的值，但是这并不意味着slice是引用传递，slice传参也是值传递。只不过slice这个结构里有一个指针指向底层的数组，实参把值拷贝给形参的时候，形参slice里的指针和外部实参slice的指针的值相同，也就指向了同一块数组内存空间，所以形参slice对数组元素做修改也会影响外部实参的值。

      // changeArray无法改变实参数组的值
      func changeArray(array [3]int) {
          array[0] = 10
      }
      
      // changeArray2可以改变实参的值
      func changeArray2(array *[3]int) {
          array[0] = 10
      }
      
      // changeArray3可以改变实参的值
      func changeArray3(array []int) {
          array[0] = 10
      }
      
      param := [3]int{1,2,3}
      changeArray(param)
      fmt.Println("param=", param) // param= [1 2 3]
      changeArray2(&param)
      fmt.Println("param=", param) // param= [10 2 3]
      
      sliceArray := []int{1,2,3}
      changeArray3(sliceArray)
      fmt.Println("sliceArray=", sliceArray) // sliceArray= [10 2 3]