Go语言数组

Go语言提供了数组类型的数据结构。数组时具有相同唯一类型的一组已编号且长度固定的数据项序列，中类型可以是任意的原始类型如整形、字符串或者自定义类型。
相对于声明number0，number1，...，and number99的变量，使用数组形式numbers[0]，numbers[1]，...，numbers[99]更加方便且易于扩展。数组元素可以通过索引(位置)来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推，如下图所示：

声明数组
Go语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式，数组长度必须是整数且大于0。例如以下定义了数组balance长度为10类型为float32：

var balance [10] float32

初始化数组
以下演示了数组初始化：

var balance = [5] float{1000.0, 2.0, 3.4, 7.0, 50.0}

初始化数组{}中的元素个数不能大于[]中的数字，如果忽略[]中的数字不设置大小，Go语言会根据元素的个数来设置数组的大小：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

该实例与上面的实例是一样的，虽然没有设置数组的大小：

balance[4] = 50.0

以上实例读取了第五个元素，数组元素可以通过索引(位置)来读取(或者修改)，索引从0开始，第一个元素索引为0，第二个索引为1，以此类推，如下图所示：

访问数组元素
数组元素可以通过索引(位置)来读取，格式为数组名后加中括号，中括号中为索引值，例如：

float32 salary = balance[9]

以上实例读取了数组balance第10个元素的值，以下演示了数组完整操作(声明、赋值、访问)的实例：

package main

import "fmt"

func main(){
    var n [10] int    /* n 是一个长度为10的数组 */
    var i, j int
    
    /* 为数组 n 初始化元素 */
    for i = 0; i < 10; i++ {
        n[i] = i + 100    /* 设置元素为 i + 100 */
    }
    
    /* 输出每个数组元素的值 */
    for j = 0; j < 10; j++ {
        fmt.Printf("Element[%d] = %d\n", j, n[j]
    }
}

以上实例运行结果为：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

跟过内容
数组对Go语言来说是非常重要的，以下介绍将介绍数组更多类容：

Go语言多维数组
Go语言支持多维数组，以下为常用的多维数组声明方式：

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

以下实例声明了三维的整形数组：

var threedim [5][10][4] int

二维数组
二维数组是最简单的多维数组，二维数组本质上是由一维数组组成的，二维数组定义方式如下：

var arrayName [x][y] variable_type

variable_type 为Go语言的数据类型，arrayName为数组名，二维数组可以认为是一个表格，x为行，y为列，下图演示了一个二维数组a为三行四列：

二维数组中的元素可以通过a[i][j]来访问。
初始化二维数组
多维数组可以通过大括号来初始化，以实例为一个3行4列的二位数组：

a = [3][4]int {
     {0, 1, 2, 3} ,   /*  第一行索引为 0 */
     {4, 5, 6, 7} ,   /*  第二行索引为 1 */
     {8, 9, 10, 11}   /*  第三行索引为 2 */
}

访问二维数组
二维数组通过指定坐标来访问，如数组中的行索引与列索引，例如：

int val = a[2][3]

以上实例访问了二维数组val第三行第四列的元素(第三行的第四个元素)，二维数组可以使用循环嵌套来输出元素：

package main

import "fmt"

func main() {
    /* 数组 - 5行 2列 */
    var a = [5][2] int { {0,0}, {1,2}, {2,4}, {3,6}, {4,8} }
    var i, j int
    
    /* 输出数组元素 */
    for i = 0; i < 5; i++ {
        for j = 0; j < 2; j++ {
            fmt.Printf("a[%d][%d] = %d\n", i, j, a[i][j])
        }
    }
}

以上实例运行输出结果为：

a[0][0] = 0
a[0][1] = 0
a[1][0] = 1
a[1][1] = 2
a[2][0] = 2
a[2][1] = 4
a[3][0] = 3
a[3][1] = 6
a[4][0] = 4
a[4][1] = 8

Go语言向函数传递数组
如果我们想向函数传递数组参数，需要在函数定义时，声明形参为数组，可以通过以下两种方式来声明：
方式一：形参设定数组大小

void myFunction(param [10] int) {
    .
    .
    .
}

方式二：形参未设定数组大小

void myFunction(param [] int) {
    .    
    .
    .
}

以下实例中函数接收整形数组参数，另一个参数指定了数组元素的个数，并返回平均值：

func getAverage(arr []int, size int) float32 {
    var i int
    var avg, sum float32
    
    for i = 0; i < size; ++i {
        sum += arr[i]
    }
    
    avg = sum / size
    
    return avg
}

接下来我们调用这个函数：

package main

import "fmt"

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

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

   /* 输出返回的平均值 */
   fmt.Printf( "平均值为: %f ", avg );
}
func getAverage(arr []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;
}

以上实例执行结果为：

平均值为: 214.399994

以上实例中我们是以哦那个的形参并为设定数组大小，浮点数计算输出有一定的偏差，我们也可以转整形来设置精度，代码如下：

package main
import (
    "fmt"
)
func main() {
    a := 1.69
    b := 1.7
    c := a * b      // 结果应该是2.873
    fmt.Println(c)  // 输出的是2.8729999999999998
}

设定固定精度：

package main
import (
    "fmt"
)
func main() {
    a := 1690           // 表示1.69
    b := 1700           // 表示1.70
    c := a * b          // 结果应该是2873000表示 2.873
    fmt.Println(c)      // 内部编码
    fmt.Println(float64(c) / 1000000) // 显示
}