Golang 基础教程

Golang 控制语句

Golang 函数 & 方法

Golang 结构体

Golang 切片 & 数组

Golang 字符串(String)

Golang 指针

Golang 接口

Golang 并发

Golang 异常(Error)

Golang 其他杂项

Go 语言数组

Go编程语言中的数组与其他编程语言非常相似。在程序中,有时我们需要存储一组相同类型的数据,例如学生分数列表。这种类型的集合使用数组存储在程序中。数组是固定长度的序列,用于将同类元素存储在内存中。由于它们的固定长度数组不像Go语言中的Slice(切片)这样受欢迎。
在数组中,允许在其中存储零个或零个以上的元素。通过使用[]索引运算符及其从零开始的位置对数组的元素进行索引,这意味着第一个元素的索引为array [0],最后一个元素的索引为array [len(array)-1]

golang中的数组

创建和访问数组

在Go语言中,数组是通过两种不同的方式创建的:

  • 使用var关键字:在Go语言中,使用具有名称,大小和元素的特定类型的var关键字创建数组。

    语法:

    Var array_name[length]Type
    或
    var array_name[length]Typle{item1, item2, item3, ...itemN}

    重要事项:

    • 在Go语言中,数组是可变的,因此您可以在分配的左侧使用array [index]语法在给定索引处设置数组的元素。

      Var array_name[index] = element[object Object]
    • 您可以使用索引值或使用for循环来访问数组的元素。

    • 在Go语言中,数组类型是一维的。

    • 数组的长度是固定的,不能更改。

    • 您可以将重复的元素存储在数组中。

    • //使用var关键字创建一个数组
      //使用其索引值访问数组
      package main
      
      import "fmt"
      
      func main() {
      
          //使用var关键字,创建一个字符串类型的数组
          var myarr [3]string
      
          //使用索引分配元素
          myarr[0] = "GFG"
          myarr[1] = "www.nhooo.com"
          myarr[2] = "nhooo"
      
          //访问数组的元素
          //使用索引值
          fmt.Println("数组的元素:")
          fmt.Println("元素 1: ", myarr[0])
          fmt.Println("元素 2: ", myarr[1])
          fmt.Println("元素 3: ", myarr[2])
      }

      输出:

      数组的元素:
      元素 1:  GFG
      元素 2:  www.nhooo.com
      元素 3:  nhooo
  • 使用简写声明:在Go语言中,数组也可以使用简写声明进行声明。它比上面的声明更灵活。

    语法:

    array_name:= [length]Type{item1, item2, item3,...itemN}[object Object]
    //使用简写声明的数组
    //使用for循环访问数组
    package main
    
    import "fmt"
    
    func main() {
    
        //数组的简写声明
        arr := [4]string{"nhooo", "gfg", "nhooos1231", "www.nhooo.com"}
    
        //访问的元素,使用for循环的数组
        fmt.Println("数组的元素:")
    
        for i := 0; i < 3; i++ {
            fmt.Println(arr[i])
        }
    
    }

    输出:

    数组的元素:
    nhooo
    gfg
    nhooos1231
  • 多维数组

    我们已经知道数组是一维的,但是允许创建多维数组。多维数组是相同类型数组的数组。在Go语言中,您可以使用以下语法创建多维数组:

    Array_name[Length1][Length2]..[LengthN]Type

    您可以使用Var关键字使用简写声明来创建多维数组,如下例所示。

    注意:在多维数组中,如果用户未使用某个值初始化单元格,则编译器将自动将其初始化为零。Golang中没有未初始化的概念。

    package main
    
    import "fmt"
    
    func main() {
    
        //创建和初始化
        //二维数组
        //使用简写声明
        //这里需要用(,)逗号
        arr := [3][3]string{{"C#", "C", "Python"},
            {"Java", "Scala", "Perl"},
            {"C++", "Go", "HTML"}}
    
        //访问的值
        //数组使用for循环
        fmt.Println("数组的元素 1")
        for x := 0; x < 3; x++ {
            for y := 0; y < 3; y++ {
                fmt.Println(arr[x][y])
            }
        }
    
        //创建二维数组
        //使用var关键字的数组
        //并初始化一个
        //使用索引的维数组
        var arr1 [2][2]int
        arr1[0][0] = 100
        arr1[0][1] = 200
        arr1[1][0] = 300
        arr1[1][1] = 400
    
        //访问数组的值
        fmt.Println("数组的元素 2")
        for p := 0; p < 2; p++ {
            for q := 0; q < 2; q++ {
                fmt.Println(arr1[p][q])
    
            }
        }
    }

    输出:

    数组的元素 1
    C#
    C
    Python
    Java
    Scala
    Perl
    C++
    Go
    HTML
    数组的元素 2
    100
    200
    300
    400

    关于数组的注意事项

  • 在数组中,如果未显式初始化数组,则此数组默认值为0

    package main 
      
    import "fmt"
      
    func main() { 
      
    //创建一个int类型的数组,存储两个元素
    //在这里,我们不初始化数组,所以数组的值为零
    var myarr[2]int 
    fmt.Println("数组元素 :", myarr) 
      
    }

    输出:

    数组元素 : [0 0]
  • 在数组中,您可以使用len()方法获取数组的长度,如下所示:

    package main
    
    import "fmt"
    
    func main() {
    
        //创建数组
        //使用简写声明
        arr1 := [3]int{9, 7, 6}
        arr2 := [...]int{9, 7, 6, 4, 5, 3, 2, 4}
        arr3 := [3]int{9, 3, 5}
    
        // 使用len方法计算数组大小
        fmt.Println("数组1的长度是:", len(arr1))
        fmt.Println("数组2的长度是:", len(arr2))
        fmt.Println("数组3的长度是:", len(arr3))
    }

    输出:

    数组1的长度是: 3
    数组2的长度是: 8
    数组3的长度是: 3
  • 在数组中,如果省略号“ ...”在长度位置处可见,则数组的长度由初始化的元素确定。如下例所示:

    //数组中省略号的使用方法
    package main
    
    import "fmt"
    
    func main() {
    
        //创建大小已确定的数组
        //根据其中元素的数量
        //使用省略号
        myarray := [...]string{"GFG", "gfg", "nhooos", "www.nhooo.com", "nhooo"}
    
        fmt.Println("数组元素: ", myarray)
    
        //数组的长度
        //由...决定
        //使用len()方法
        fmt.Println("数组的长度为:", len(myarray))
    }

    输出:

    数组元素:  [GFG gfg nhooos www.nhooo.com nhooo]
    数组的长度为: 5
  • 在数组中,允许您在array 的元素范围内进行迭代。如下例所示:

    //如何迭代数组
    package main
    
    import "fmt"
    
    func main() {
    
        //创建一个数组,其大小
        //用省略号表示
        myarray := [...]int{29, 79, 49, 39, 20, 49, 48, 49}
    
        //使用for循环迭代数组
        for x := 0; x < len(myarray); x++ {
            fmt.Printf("%d\n", myarray[x])
        }
    }

    输出:

    29
    79
    49
    39
    20
    49
    48
    49
  • 在Go语言中,数组的值类型不是引用类型。因此,当将数组分配给新变量时,在新变量中所做的更改不会影响原始数组。如下例所示:

    package main
    
    import "fmt"
    
    func main() {
    
        //创建一个数组,其大小
        //用省略号表示
        my_array := [...]int{100, 200, 300, 400, 500}
        fmt.Println("原始数组(改变前):", my_array)
    
        //创建一个新变量
        //并使用my_array进行初始化
        new_array := my_array
    
        fmt.Println("新数组(改变前):", new_array)
    
        //将索引0处的值更改为500
        new_array[0] = 500
    
        fmt.Println("新数组(改变后):", new_array)
    
        fmt.Println("原始数组(改变后):", my_array)
    }

    输出:

    原始数组(改变前): [100 200 300 400 500]
    新数组(改变前): [100 200 300 400 500]
    新数组(改变后): [500 200 300 400 500]
    原始数组(改变后): [100 200 300 400 500]
  • 在数组中,如果数组的元素类型是可比较的,则数组类型也是可比较的。因此,我们可以使用==运算符直接比较两个数组。如下例所示:

    //如何比较两个数组
    package main
    
    import "fmt"
    
    func main() {
    
        arr1 := [3]int{9, 7, 6}
        arr2 := [...]int{9, 7, 6}
        arr3 := [3]int{9, 5, 3}
    
        //使用==运算符比较数组
        fmt.Println(arr1 == arr2)
        fmt.Println(arr2 == arr3)
        fmt.Println(arr1 == arr3)
    
        //这将给出和错误,因为
        // arr1和arr4的类型不匹配
        /*
           arr4:= [4]int{9,7,6}
           fmt.Println(arr1==arr4)
        */
    }

    输出:

    true
    false
    false