Go语言【第九篇】：Go数据结构之：数组

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语言多维数组

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) // 显示

}

巴特西

Go语言【第九篇】：Go数据结构之：数组

Go语言数组

最新文章

热门文章