Go语言 数组

  • 数组

    Go编程语言提供了一种称为array的数据结构,该数据结构可以存储相同类型的元素的固定大小的顺序集合。数组用于存储数据集合,但是将数组视为相同类型的变量集合通常会更有用。无需声明单个变量(例如,number0,number1,...和number99),而是声明一个数组变量(例如,numbers),并使用numbers [0],numbers [1]和...,numbers [99]表示各个变量。数组中的特定元素由索引访问。所有数组均包含连续的内存位置。最低地址对应于第一个元素,最高地址对应于最后一个元素。
    images
  • 声明数组

    要在Go中声明数组,程序员可以指定元素的类型和数组所需的元素数量,如下所示-
    
    var variable_name [SIZE] variable_type
    
    这称为一维数组。所述SIZE必须是整数大于零的常数和variable_type可以是任何有效转到数据类型。例如,要声明一个称为balance类型为float32 长度为10元素数组,请使用此语句-
    
    var balance [10] float32
    
    在这里,balance是一个可变数组,最多可容纳10个浮点数。
  • 初始化数组

    您可以在Go中一个接一个地初始化数组,也可以使用一个语句来初始化数组,如下所示:
    
    var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    
    大括号{}之间的值的数量不能大于我们为方括号[]之间的数组声明的元素数。如果省略数组的大小,则会创建一个大小足以容纳初始化的数组。因此,如果您写-
    
    var balance = []float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    
    您将创建与上一个示例完全相同的数组。以下是分配数组的单个元素的示例-
    
    balance[4] = 50.0
    
    上面的语句为数组中的第5个元素分配了50.0的值。所有数组的第一个元素的索引均为0,也称为基本索引,数组的最后一个索引为数组的总大小减去1。以下是我们上面讨论的同一数组的图形表示-
    images
  • 访问数组元素

    通过索引数组名称来访问元素。这是通过将元素的索引放在数组名称后面的方括号内来完成的。例如
    
    float32 salary = balance[9]
    
    上面的语句将从数组中获取第 10 个元素,并将值分配给salary变量。以下是一个示例,它将使用上述所有三个概念。声明,赋值和访问数组-
    
    package main
    
    import "fmt"
    
    func main() {
       var n [10]int /* n is an array of 10 integers */
       var i,j int
    
       /* initialize elements of array n to 0 */         
       for i = 0; i < 10; i++ {
          n[i] = i + 100 /* set element at location i to i + 100 */
       }
       
       /* output each array element's value */
       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编程语言允许多维数组。这是多维数组声明的一般形式-
    
    var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
    
    例如,以下声明创建了三维5*10*4个整数数组-
    
    var threedim [5][10][4]int
    
    多维数组的最简单形式是二维数组。
    
    var arrayName [ x ][ y ] variable_type
    
    其中variable_type可以是任何有效的Go数据类型,而arrayName是有效的Go标识符。可以将二维数组视为一个表,该表将具有x的行数和y的列数。包含三行四列的二维数组a可以显示如下-
    images
    因此,数组a中的每个元素都由形式为a [i] [j]的元素名称标识,其中a是数组的名称,而i和j是唯一标识a中每个元素的下标。
    初始化二维数组,可以通过为每行指定括号中的值来初始化多维数组。以下是具有3行的数组,每行有4列。
    
    a = [3][4]int{  
       {0, 1, 2, 3} ,   /*  initializers for row indexed by 0 */
       {4, 5, 6, 7} ,   /*  initializers for row indexed by 1 */
       {8, 9, 10, 11}   /*  initializers for row indexed by 2 */
    }
    
    访问二维数组元素
    使用下标访问二维数组中的元素,即数组的行索引和列索引。例如-
    
    int val = a[2][3]
    
    上面的语句将从数组的第三行获取第4个元素。您可以在上图中进行验证。让我们检查下面的程序,其中我们使用嵌套循环来处理二维数组-
    
    package main
    
    import "fmt"
    
    func main() {
       /* an array with 5 rows and 2 columns*/
       var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}
       var i, j int
    
       /* output each array element's value */
       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
    
    如上所述,您可以具有任意数量的维度数组,尽管您创建的大多数数组可能都是一维或二维的。
    将数组传递给函数
    如果要将一维数组作为函数的参数传递,则必须以以下两种方式之一声明函数形式参数,并且所有两种声明方法均会产生相似的结果,因为每种方法都告诉编译器整数数组在运行被接收。您可以类似的方式将多维数组作为形式参数传递。
    形式参数作为大小数组如下-
    
    void myFunction(param [10]int)
    {
    .
    .
    .
    }
    
    形式参数作为未调整大小的数组,如下所示--
    
    void myFunction(param []int)
    {
    .
    .
    .
    }
    
    现在,考虑以下函数,该函数将数组作为参数以及另一个参数,并基于传递的参数,返回通过数组的数字的平均值,如下所示:
    
    func getAverage(arr []int, int size) 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() {
       /* an int array with 5 elements */
       var  balance = []int {1000, 2, 3, 17, 50}
       var avg float32
    
       /* pass array as an argument */
       avg = getAverage( balance, 5 ) ;
    
       /* output the returned value */
       fmt.Printf( "Average value is: %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 / size)
       return avg;
    }
    
    尝试一下
    将以上代码编译在一起并执行后,将产生以下结果-
    
    Average value is: 214.400000
    
    正如您所看到的,就函数而言,数组的长度无关紧要,因为Go对形式参数不执行任何边界检查。