9-Golang复合数据类型-array(数组)

数组是具有相同类型的数据项组成的一组长度固定的序列，数据项叫做数组的元素，数组的长度必须是非负整数的常量，长度也是类型的一部分。

声明数组

Go 语言数组声明需要指定元素类型及元素个数，在数组声明后，其长度不可修改，数组的每个元素会根据对应类型的零值对进行初始化。语法格式如下：

var variable_name [SIZE]variable_type

例如以下定义了数组 balance 长度为 10 类型为 float32：
var balance [10]float32

package main

import "fmt"

func main() {
    /*
        数组定义: 相同数据类型组成一组固定长度的序列
        数组声明: 需要指定元素类型 和元素长度  零值为元素类型的零值
    */
    var arrayint [10]int
    var arraybool [5]bool
    var arraystring [10]string
    fmt.Printf("%T %v\n", arrayint, arrayint)
    fmt.Printf("%T %v\n", arraybool, arraybool)
    fmt.Printf("%T %q\n", arraystring, arraystring)
    fmt.Printf("%T %v\n", arraystring, arraystring)

    // 字面量   赋值是创建新的数组
    // 空  零值
    arrayint = [10]int{}
    fmt.Println(arrayint)

    // 按顺序赋值前几个
    arrayint = [10]int{10, 20, 30}
    fmt.Println(arrayint)

    // 根据索引赋值
    arrayint = [10]int{0: 10, 9: 20}
    fmt.Println(arrayint)

    //[...]int{1,2,3} 推导数组长度
    arrayint0 := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(arrayint0)

    // 简短声明
    arrayint2 := [10]int{}
    fmt.Printf("%T %v\n", arrayint2, arrayint2)

    arrayint3 := [10]int{10, 20, 30}
    fmt.Printf("%T %v\n", arrayint3, arrayint3)

    arrayint4 := [5]int{0: 1, 4: 5}
    fmt.Printf("%T %v\n", arrayint4, arrayint4)

    arrayint5 := [...]int{1, 2, 3}
    fmt.Printf("%T %v\n", arrayint5, arrayint5)
}

数组的操作

package main

import "fmt"

func main() {
    arrayint5 := [...]int{1, 2, 3}
    fmt.Printf("%T %v\n", arrayint5, arrayint5)
    // 操作
    // 长度不相等，不能做操作，会报错invalid operation: nums05 == nums06 (mismatched types [3]int and [5]int)
    // 关系运算
    arrayint6 := [3]int{1, 3, 4}
    //arrayint7 := [4]int{1, 22}
    //arrayint7 := [3]int{1, 3, 4}
    arrayint7 := [3]int{1, 3}
    fmt.Println(arrayint6 == arrayint7)

    // 获取数组的长度
    fmt.Println(len(arrayint7))

    // 访问 索引 0,1,2,...len(array)-1
    // 超出索引长度会报错 invalid argument: index 3 out of bounds [0:3]
    fmt.Println(arrayint5[0], arrayint7[0])
    arrayint5[0] = 1000
    fmt.Println(arrayint5)

    // 遍历数组
    for i := 0; i <= len(arrayint5)-1; i++ {
        fmt.Println(arrayint5[i])
    }
    for i, v := range arrayint5 {
        fmt.Println(i, v)
    }
    for _, v := range arrayint5 {
        fmt.Println(v)
    }

    // 切片  数组的切片是切片类型
    s := "123123123"
    fmt.Printf("%T\n", s[1:3])
    fmt.Printf("%T\n", arrayint5[0:2:3])
    /*
        长度和容量
        cap即capacity，容量，表示给数组分配的内存空间可以容纳多少个元素
        len即length，长度，指的是容器中目前有几个元素
        由于数组创建时就必须确定的元素个数，且不能改变长度，所以不需要预留多余的内存空间，因此cap和len对数组来说相等。
    */
}

多维数组

定义格式:

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

声明二维的整型数组：
var twodim [10][4]int
二维数组中的元素可通过 twodim[ i ][ j ] 来访问。

示例:

package main

import "fmt"

func main() {
    //多维数组
    var marrays [3][2]int
    fmt.Printf("%T", marrays)
    fmt.Println(marrays)
    fmt.Println(marrays[0])
    fmt.Println(marrays[0][0])
    marrays[0] = [2]int{1, 3}
    fmt.Println(marrays)
    marrays[1][1] = 1000
    fmt.Println(marrays)

    var m3 [3][2][5]int
    fmt.Println(m3)

    marrays = [3][2]int{{1, 2}, {3, 4}}
    fmt.Println(marrays)

    for _, v := range marrays {
        for _, vv := range v {
            fmt.Print(vv, "\t")
        }
        fmt.Println()
    }
}