Go语言学习笔记11.复合类型-数组

数组

作为后端开发语言，可能数组用的是最多的了。
数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。
数组⻓度必须是常量，且是类型的组成部分。 [2]int 和 [3]int 是不同类型。
定义：

var b [10]int
v：= [10] int
//注意：定义数组时，指定的数组元素个数必须是常量
//n := 10
//var c [n]int //err non-constant array bound n

通过下标访问：len()获取数组的长度

id :=  [50]int
//操作数组，通过下标， 从0开始，到len()-1
for i := 0; i < len(id); i++ {
    id[i] = i + 1
    fmt.Printf("id[%d] = %d\n", i, id[i])
}

初始化，没有初始化的就是0

//全部初始化或部分初始化
id :=  [50]int{1,2,3,4,5}  //前面5个赋值，后面全是0
//指定某个元素初始化
d := [5]int{2: 10, 4: 20} //d =  [0 0 10 0 20]
b := [...]int{1, 2, 3}    // 通过初始化值确定数组长度

多维数组

package main //必须有个main包

import "fmt"

func main() {
    //有多少个[]就是多少维
    //有多少个[]就用多少个循环
    var a [3][4]int

    k := 0
    for i := 0; i < 3; i++ {
        for j := 0; j < 4; j++ {
            k++
            a[i][j] = k
            fmt.Printf("a[%d][%d] = %d, ", i, j, a[i][j])
        }
        fmt.Printf("\n")
    }
    /*
        a[0][0] = 1, a[0][1] = 2, a[0][2] = 3, a[0][3] = 4,
        a[1][0] = 5, a[1][1] = 6, a[1][2] = 7, a[1][3] = 8,
        a[2][0] = 9, a[2][1] = 10, a[2][2] = 11, a[2][3] = 12,
    */

    fmt.Println("a = ", a)//a =  [[1 2 3 4] [5 6 7 8] [9 10 11 12]]

    //多维数组初始化
    //有3个元素，每个元素又是一维数组[4]int
    b := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    fmt.Println("b = ", b)

    //部分初始化，没有初始化的值为0
    c := [3][4]int{{1, 2, 3}, {5, 6, 7, 8}, {9, 10}}
    fmt.Println("c = ", c)//c =  [[1 2 3 0] [5 6 7 8] [9 10 0 0]]

    d := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
    fmt.Println("d = ", d)//d =  [[1 2 3 4] [5 6 7 8] [0 0 0 0]]

    e := [3][4]int{1: {5, 6, 7, 8}} 
    fmt.Println("e = ", e)//e =  [[0 0 0 0] [5 6 7 8] [0 0 0 0]]
}

数组遍历

//for循环遍历
for i := 0; i < len(a); i++ {
    fmt.Printf("a[%d] = %d\n", i, a[i])
}

//迭代器遍历
//第一个返回下标，第二个返回元素
for i, data := range a {
    fmt.Printf("a[%d] = %d\n", i, data)
}

数组的比较和赋值

package main //必须有个main包

import "fmt"

func main() {
    //支持比较，只支持 == 或 !=, 比较是不是每一个元素都一样，2个数组比较，数组类型要一样
    a := [5]int{1, 2, 3, 4, 5}
    b := [5]int{1, 2, 3, 4, 5}
    c := [5]int{1, 2, 3}
    fmt.Println(" a == b ", a == b) //a == b  true
    fmt.Println(" a == c ", a == c) //a == c  false

    //同类型的数组可以赋值
    var d [5]int
    d = a
    fmt.Println("d = ", d)
}

数组做参数

package main

import "fmt"

func main() {
   /* 数组长度为 5 */
   var  balance = [5]int {1000, 2, 3, 17, 50}
   var avg float32

   /* 数组作为参数传递给函数 */
   avg = getAverage( balance, 5 ) ;

   /* 输出返回的平均值 */
   fmt.Printf( "平均值为: %f ", avg );
}
func getAverage(arr [5]int, size int) float32 {
   var i,sum int
   var avg float32  

   for i = 0; i < size;i++ {
      sum += arr[i]
   }

   avg = float32(sum) / float32(size)

   return avg;
}

数组指针

一个int需要8套别墅，8个int需要64套别墅，一样的道理，只需要告诉别人首地址，然后后面64套都是我的，别人怎么知道64？因为通过类型和长度可以推导出来。

package main //必须有个main包

import "fmt"

func modify(p *[5]int) {
    (*p)[0] = 666
    fmt.Println("modify *a = ", *p) //modify *a =  [666 2 3 4 5]
}

func main() {
    a := [5]int{1, 2, 3, 4, 5} //初始化

    modify(&a) //地址传递
    fmt.Println("main: a = ", a) //main: a =  [666 2 3 4 5]
}

这里数组指针做函数参数就很明显可以看出来，是传引用（地址传递），而数组做参数是值传递。