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
登录
请登录后再发表评论。
评论列表:
目前还没有人发表评论