golang 数组

1.数组的定义

var 数组名 [数组大小]数据类型  

var a [3]int  赋初值 a[0]=1 a[1]=2...

数组是值类型，数组指向第一个元素的值。数组的首地址是第一个元素的地址。数组元素地址的间隔是依据数组的间隔决定的

//求总重与平均体重
func main() {
    var hens [2]float64
    hens[0] = 1.0
    hens[1] = 2.0
    totanum := 0.0
    for i := 0; i < len(hens); i++ {
        totanum += hens[i]
    }

    avg := fmt.Sprintf("%.2f", totanum/float64(len(hens)))

    fmt.Printf("总体重为：%v,平均体重为：%v", totanum, avg)

}

 2.数组的四种定义方式

func main() {
    //四种初始化数组的方式
    var numArr01 [3]int = [3]int{1, 2, 3}
    fmt.Println("numArr01=", numArr01)

    var numArr02 = [3]int{1, 2, 3}
    fmt.Println("numArr01=", numArr02)
    //这里的[...]为规定的写法
    var numArr03 = [...]int{1, 2, 3}
    fmt.Println("numArr01=", numArr03)
    //指定下标
    var numArr04 = [...]int{1: 200, 0: 1, 2: 312}
    fmt.Println("numArr01=", numArr04)
    //类型推导
    strArr05 := [...]string{1: "tom", 0: "jack", 2: "lili"}
    fmt.Println("strArr05=", strArr05)
}

3.数组的遍历 for range

for range是go语言的一种独有的结构，可以用来遍历访问数组的元素

func main() {
    var numArr03 = [...]int{1, 2, 3}
    fmt.Println("numArr01=", numArr03)
    for _, val := range numArr03 {
        fmt.Println(val)
    }
}

4.数组的注意事项和细节

1）一个数组一旦声明、定义了，其长度是固定的，不能动态变化。

2）var arr []int   的[]中没有数字，这就不是数组而是切片

3)  数组中的元素可以是任何数据类型包括值类型和引用类型，但是不能混用

4）数组建立后，如果没有赋值，默认为0

5)  数组的下标是从0开始的。数组属于值类型，在默认情况下是值传递，因为进行的是值拷贝，数组间互相不会影响，因为main函数和test函数中的内存栈不是一个。

6)　如果要在test函数中改变main函数的数组，则可以用引用传递（指针&）的方式

func test(numArr01 [3]int) {
    numArr01[0] = 60
    fmt.Println("test函数中：", numArr01)
}
func test1(numArr01 *[3]int) {
    (*numArr01)[0] = 70
}
func main() {
    numArr01 := [...]int{88, 12, 30}
    test(numArr01)
    fmt.Println("主函数中：", numArr01)
    test1(&numArr01)
    fmt.Println("主函数中：", numArr01)
}

5.数组应用实例

1）求一个数组的平均值

func avg() {
    num1 := [...]float64{1, 4, 89, 3, 10, 3, 2, 7}
    total := 0.0
    for i := 0; i < len(num1); i++ {
        total += num1[i]
    }
    avg := total / float64(len(num1))
    fmt.Println(avg)
}

2）求一个数组的最大值，并得到对应的下标

func max1() {
    num1 := [...]int{1, 4, 89, 3, 10, 3, 2, 7}
    m1 := 0
    t := 0
    for i := 0; i < len(num1); i++ {
        if num1[i] > m1 {
            m1 = num1[i]
            t = i
        }
    }
    fmt.Println("下标为：", t, "最大值为：", m1)
}

3)创建一个byte类型的26个元素的数组，分别放置'A'-'Z'，使用for循环访问所有元素并打印出来。'A' + 1 -> 'B'

func AZ() {
    var az [26]byte
    for i := 0; i < 26; i++ {
        //注意将i转成byte类型
        az[i] = 'A' + byte(i)
    }
    fmt.Printf("%c", az)
}

4)随机生成5个数并将其反转打印

func fzp() {
    var ns [5]float64
    for i := 0; i < len(ns); i++ {
        rand.Seed(time.Now().UnixNano())
        ns[i] = float64(rand.Intn(100))
    }
    fmt.Println(ns)
    temp := 0.0
    for j := 0; j < len(ns)/2; j++ {
        temp = ns[len(ns)-j-1]
        ns[len(ns)-j-1] = ns[j]
        ns[j] = temp
    }
    fmt.Println(ns)

}