登录 主页

go - array

2024-01-30 12:11PM

参考:https://www.geeksforgeeks.org/arrays-in-go/

数组是一个固定长度的序列,用于在内存中储存同类型的元素。

在数组中,你可以储存零个或多个元素。数组的元素使用 [] 索引运算符使数组从零的位置开始对数组元素进行索引,这意味着第一个元素的索引是 array[0],最后一个元素的索引是 array[len(array)-1]。

1. 创建和访问数组

在 go 语言中,数组有两种不同的创建方式:

1) 使用 var 关键字:

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

语法:

var array_name[length]Type

注意:go 语言中,数组是可变的,因此你可以在赋值的左侧使用 array[index] 语法来设置给定索引处的数组元素

var array_name[index] = element

你可以使用索引值或使用 for 循环来访问数组的元素。

在go语言,数组类型是一维的

数组的长度是固定的,不可更改

允许你在数组中存储重复的元素

2) 使用简写声明:

go 语言,数组也可以使用简写来声明,它比 var 关键字声明更灵活

array_name:= [length]Type{item1, item2, item3,...itemN}

eg:创建 go_array.go 文件

// 使用简写声明的数组
// 并访问元素
// 使用for循环的数组
package main
import "fmt"
func main() {
  // 使用简写方式声明数组
  arr := [4]string{"geek", "gfg", "Geeks123", "GeeksforGeeks"}
  // 使用for循环访问数组元素
  for i := 0; i < 3; i++ {
    fmt.Println("数组的元素:", arr[i])
  }
}

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run go_array.go 
数组的元素: geek
数组的元素: gfg
数组的元素: Geeks123 

2. 多维数组 

我们已经知道数组是一维的,但是我们可以创建多维数组,多维数组是相同类型数组的数组。

语法:

array_name[Length1][Length2]..[LengthN]Type

你可使用 var 关键字或使用简写声明来创建多维数组

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

eg:创建go_array_more.go 文件

// 多维数组的概念                                                                                     
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])                                                                         
    }                                                                                                 
  }                                                                                                   
}    

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run go_array_more.go 
数组1的元素
C #
C
Python
Java
Scala
Perl
C++
Go
HTML
数组2的元素
100
200
300
400

3. 关于数组的重要观察

1) 在数组中,如果数组没有显示/定义初始化的值,则该数组的默认值为0

eg:创建 array_default_value.go  文件

package main

import "fmt"

func main() {

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

 运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array_default_value.go 
数组的元素: [0 0]

 2) 在数组中,你可以使用 len() 方法查找数组的长度

eg:创建 array_len.go 文件

package main

import "fmt"

func main() {

  // Go程序演示如何找到数组的长度

  // 创建数组
  // 使用简写方式声明
  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))
}

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array_len.go 
数组1的长度为: 3
数组2的长度为: 8
数组3的长度为: 3

3) 在数组中,如果长度是省略号"…“ ,则数组的长度由初始化的元素决定

eg:创建 array_length.go 文件

package main

import "fmt"

func main() {

  // Go程序演示数组中省略号(ellipsis)的概念

  // 创建一个由元素数量决定大小的数组
  // 使用省略号
  myarray := [...]string{"GFG", "gfg", "geeks",
    "GeeksforGeeks", "GEEK"}

  fmt.Println("数组的元素:", myarray)

  // 使用 len() 方法确定数组的长度
  fmt.Println("数组的长度为:", len(myarray))
}

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array_length.go 
数组的元素: [GFG gfg geeks GeeksforGeeks GEEK]
数组的长度为: 5 

4) 在数组中,你可以迭代数组元素的范围

eg:创建 array_iterate.go

package main

import "fmt"

func main() {

  // Go程序演示如何迭代数组

  // 创建一个由省略号表示大小的数组
  myarray := [...]int{29, 79, 49, 39,
    20, 49, 48, 49}

  // 使用 for 循环迭代数组
  for x := 0; x < len(myarray); x++ {
    fmt.Printf("%d\n", myarray[x])
  }
}

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array_iterate.go 
29
79
49
39
20
49
48
49
 

5)在Go语言中,数组是值类型而不是引用类型。因此,当将数组赋值给一个新变量时,对新变量所做的更改不会影响原始数组。 

eg:创建 go_value_type.go

package main

import "fmt"

func main() {

  // Go程序演示值类型的数组

  // 创建一个由省略号表示大小的数组
  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)
}

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array_value_type.go 
原始数组(修改前): [100 200 300 400 500]
新数组(修改前): [100 200 300 400 500]
新数组(修改后): [500 200 300 400 500]
原始数组(修改后): [100 200 300 400 500] 

6)在数组中,如果数组的元素类型是可比较的,那么数组类型也是可比较的。因此,我们可以使用 == 运算符直接比较两个数组。 

eg:创建 array.go 文件

package main

import "fmt"

func main() {

  // Go程序演示如何比较两个数组

  // 数组
  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)
  */
}

 

运行结果:

meiyi@meiyi-Extensa-2511G:~/workspace/go$ go run array.go 
true
false
false 

返回>>

登录

请登录后再发表评论。

评论列表:

目前还没有人发表评论