go 数组

浮点型计算格式化小数位数方法

//保留两位小数，四舍五入
avgWeight := fmt.Sprintf( "%.2f",totalWeight /6 )

数组

• 数组可以存放多个同一类型数据。数组是值类型。
  入门案例

    var hens [6]float64
    hens[0] = 3.0
    hens[1] = 5.0
    hens[2] = 1.0
    hens[3] = 3.4
    hens[4] = 2.0
    hens[5] = 50.0
    totalWeight := 0.0
    for i := 0; i < len(hens); i++ {
        totalWeight += hens[i]
    }
    avgWeight := fmt.Sprintf("%.2f", totalWeight/float64(len(hens)))
    fmt.Printf("totalWeight=%v,avgWeight=%v \n", totalWeight, avgWeight)

数组定义和内存分布

• 数组的定义

var 数组名 [数组大小] 数据类型
var a [5]int
赋值 a[0]=1 a[1]=30 ....

• 数组内存图

  
  

    var intArr [3]int //1个int占8个字节
    //定义完数组后，数组的每个元素默认值是0
    fmt.Println(intArr)
    intArr[0] = 10
    intArr[1] = 20
    intArr[2] = 30
    fmt.Println(intArr)

    fmt.Printf("intArr的地址=%p intArr[0]的地址：%p intArr[1] 地址%p \n",
        &intArr, &intArr[0], &intArr[1])

小结：
1、数组的地址可以通过数组名来获取&intArr
2、数组的第一个元素的地址，就是数组的首地址
3、数组的各个元素的地址间隔是依据数组的类型决定的。比如 int64-->8字节 int32-->4字节

数组的使用

• 数组的访问

数组名[下标] 比如：要使用a数组的第三个元素 a[2]

案例：

从终端循环输入5个成绩，保存到float64数组中，并输出

    var arr [5]float64

    for i := 0; i < 5; i++ {
        fmt.Printf("输入第%v个数组元素\n", i+1)
        fmt.Scanln(&arr[i])
    }
    //打印数组
    for i := 0; i < 5; i++ {
        fmt.Printf("arr[%d]=%v \n", i, arr[i])
    }

• 五种初始化数组的方式

    var numArr01 [3]int = [3]int{1, 2, 3}
    fmt.Println("numArr01=", numArr01)

    var numArr02 = [3]int{4, 5, 6}
    fmt.Println("numArr02=", numArr02)

    var numArr03 = [...]int{7, 8, 9}
    fmt.Println("numArr03=", numArr03)

    var numArr04 = [...]int{1: 44, 0: 55, 2: 66}
    fmt.Println("numArr04=", numArr04)

    strArr05 := [...]string{1: "tome", 0: "jack", 2: "steven"}
    fmt.Println("strArr05=", strArr05)

数组的遍历

1、常用的for循环遍历
2、for-range结构遍历
基本语法

for index,value :=range array01 {
...
}

• 2.1 index是数组的下标
• 2.2 value是该下标对应的值
• 2.3 index和value都是仅在for循环内部的局部变量
• 2.4 遍历数组的时候，如果不想使用下标index，可以用_（占位符）来代替
• 2.5 index和value的名称不是固定的，可以自定义，一般命名为index和value

    heros := [...]string{"宋江", "吴用", "卢俊义"}

    for i, v := range heros {
        fmt.Printf("i=%v,v=%v\n", i, v)
    }

    for _, v := range heros {
        fmt.Printf("元素的值=%v\n", v)
    }

数组的使用和细节

1、数组是多个相同类型的数据组合，数组一量声明/定义，长度固定，不能动态变化

    var arr01 [3]int
    arr01[0] = 1
    arr01[1] = 10
    arr01[2] = 1.1 //会报错，数据类型不一样

2、var arr[]int这时arr就是一个slice切片。
3、数组中的元素可以是任何数据类型，包括值类型和引用类型。但不能混用。
4、数组创建后，如果没有赋值，有默认值

• 数值类型 ： 默认是0
• 字符串：默认是""
• bool数组 默认是false

5、数组使用步骤：

• 1.声明数组并开辟空间
• 2.给数组各个元素赋值（默认）
• 3.使用数组
  6、数组下标从0开始的
  7、数组下标必须在指定范围使用，否则报panic:数组越界
  8、Go的数组属值类型，在默认情况下是值传递，因些会进行值拷贝

func test(arr [3]int) {
    arr[0] = 88
}
func main() {
    arr := [3]int{11, 22, 33}
    test(arr)
    fmt.Println(arr)
}

9、如想在其它函数中，去修改原来的数组，可以使用引用传递（指针方式）

func test(arr *[3]int) {
    fmt.Printf("test函数中arr指针的地址=%p \n", &arr)
    (*arr)[0] = 88 //指针引用！！
}
func main() {
    arr := [3]int{11, 22, 33}
    fmt.Printf("main主函数中arr的地址=%p \n", &arr)
    test(&arr)
    fmt.Println(arr)
}

10、长度是数组类型的一个部分，在传递函数参数时，需要考虑数组的长度