【入门】Go语言数组详解
目录
一、Go语言数组简介
1.1 什么是数组？
-
数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。
-
因为数组的长度是固定的，所以在Go语言中很少直接使用数组。
-
数组可以存放多个同一类型数据。数组也是一种数据类型，在Go中，数组是值类型。
-
数组的每个元素都可以通过索引来访问，索引起始0开始到数组长度减1的位置，内置函数len()可以返回数组中元素的个数。
1.2 数组声明语法
var 数组变量名 [元素数量]Type
- 数组变量名：数组声明及使用时的变量名
- 元素数量：数组的元素数量
- Type：可以是任意基本类型，也可以是数组本省，类型为数组本身时，可以实现多维数组。
举个例子：创建int类型的class数组，其中元素数量为5
var class [5]int
二、数组的基本操作
2.1 数组的定义及赋值
package main
import (
"fmt"
)
func main() {
var class [5]int // 定义数组
for i := 0; i < len(class); i++ {
class[i] = i + 100 // 数组赋值
}
fmt.Println(class)
}
代码输出内容：
[100 101 102 103 104]
2.2 数组的初始化
数组初始化是指在声明数组时赋值。
2.2.1 指定长度初始化
指定长度和初始化值，初始化数组中 {} 中的元素个数不能大于 [] 中的数字：
注意： 初始化时是带有 = 号的。
func main() {
var class = [4]string{"zhangsan", "lisi", "wangwu", "maliu"}
fmt.Printf("%v", class)
}
2.2.2 不指定长度初始化
当我们不指定长度的时候，也就是[]中不写入内容，GO语言默认会根据元素的个数来设置数组的大小。
package main
import (
"fmt"
)
func main() {
var class = [...]string{"zhangsan", "lisi", "wangwu", "maliu"}
fmt.Printf("%v", len(class))
}
或者使用 ...如下：
package main
import (
"fmt"
)
func main() {
var class = [...]string{1: "lisi", 3: "maliu"}
fmt.Println(len(class))
}
代码输出内容：
4
2.2.3 根据索引初始化指定元素
只初始化索引是 1和3 的元素
package main
import (
"fmt"
)
func main() {
var class = []string{1: "lisi", 3: "maliu"}
fmt.Println(class)
}
三、数组的遍历
3.1 传统for循环遍历
package main
import (
"fmt"
)
func main() {
var arr = [...]float64{1.1, 1.2, 1.3, 1.4, 1.5, 1.6}
for i := 0; i < len(arr); i++ {
fmt.Println(arr[i])
}
}
3.2 for range循环遍历
package main
import (
"fmt"
)
func main() {
var arr = [...]float64{1.1, 1.2, 1.3, 1.4, 1.5, 1.6}
for i, v := range arr {
fmt.Printf("index=%d\tvalue=%v\n", i, v)
}
}
代码输出内容：
index=0 value=1.1
index=1 value=1.2
index=2 value=1.3
index=3 value=1.4
index=4 value=1.5
index=5 value=1.6
四、数组综合练习
4.1 案例一：比较两台数组元素是否一致
package main
import "fmt"
func main() {
var arr1 = [5]int{1, 2, 3, 4, 5}
var arr2 = [5]int{1, 2, 3, 4, 5}
b := Compare(arr1, arr2)
if b {
fmt.Println("数组一致!")
} else {
fmt.Println("数组不致!")
}
}
func Compare(n1 [5]int, n2 [5]int) bool {
var b bool = true
if len(n1) == len(n2) {
for i := 0; i < len(n1); i++ {
if n1[i] == n2[i] {
continue
} else {
b = false
break
}
}
} else {
b = false
}
return b
}
4.2 案例二：从数组中查出最大整数，最小整数并且算出总和 和平均值
package main
import "fmt"
func main() {
var arr = [...]int{50, 100, 200, 300, 400, 500, 600}
var maxNum int
var minNum int = arr[0]
var sumNum int
for i := 0; i < len(arr); i++ {
sumNum += arr[i]
if arr[i] > maxNum {
maxNum = arr[i]
} else if arr[i] < minNum {
minNum = arr[i]
}
}
fmt.Printf("最大值:%d\t最小值:%d\t总和:%d\t平均:%d", maxNum, minNum, sumNum, sumNum/len(arr))
}
函数方式写法：
package main
import "fmt"
func cal(arr []int) (int, int, int) {
var maxNum int
var minNum int = arr[0]
var sumNum int
for i := 0; i < len(arr); i++ {
sumNum += arr[i]
if arr[i] > maxNum {
maxNum = arr[i]
} else if arr[i] < minNum {
minNum = arr[i]
}
}
return maxNum, minNum, sumNum
}
func main() {
var arr = [...]int{50, 100, 200, 300, 400, 500, 600}
maxNum, minNum, sumNum := cal(arr[:])
fmt.Printf("最大值:%d\t最小值:%d\t总和:%d\t平均:%d", maxNum, minNum, sumNum, sumNum/len(arr))
}
代码输出内容：
最大值:600 最小值:50 总和:2150 平均:307
4.3 案例三：输出数组中最长的字符串
package main
import (
"fmt"
)
func main() {
var names = [...]string{"张三三", "李四四五", "王五", "马六", "七七"}
strMaxLen := names[0]
for i := 0; i < len(names); i++ {
if len(names[i]) > len(strMaxLen) {
strMaxLen = names[i]
}
}
fmt.Println(strMaxLen)
}
五、二维数组
前面定义的数组只有一个下标，称之为一维数组，如果有两个下标，称之为二维数组。
5.1 二维数组声明语法
var 数组名 [x][y]类型
- x: 第一个下标代表行
- y: 第二个下标代表列
举个例子：
package main
import "fmt"
func main() {
var arr [2][3]int
arr[1][2] = 123
fmt.Println("二行三列内容:", arr[1][2])
}
简单画个图一看就懂：
5.2 二维数组初始化
语法：
var 数组名称 = [x][y]类型{{x数据}, {y数据}}
}
案例：
package main
import "fmt"
func main() {
// 初始化[0][0],[1][0],[1][1] 输出：[[200 0 0] [100 300 0]]
// var arr = [2][3]int{{200}, {100, 300}}
// 初始化[1][0],[1][1] 输出: [[0 0 0] [200 300 0]]
// var arr = [2][3]int{1: {200, 300}}
// 初始化[1][2]: 输出：[[0 0 0] [0 0 200]]
var arr = [2][3]int{1: {2: 200}}
fmt.Println(arr)
}
5.3 二维数组遍历
取行和列的长度：
package main
import "fmt"
func main() {
var arr = [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println("行:", len(arr))
fmt.Println("列:", len(arr[0]))
}
代码输出内容：
行: 2
列: 3
案例：遍历二维数组
package main
import "fmt"
func main() {
fmt.Println()
var arr = [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println("============常规for循环==============")
for i := 0; i < len(arr); i++ {
for j := 0; j < len(arr[i]); j++ {
fmt.Printf("%v\t", arr[i][j])
}
fmt.Println()
}
fmt.Println("============for range循环==============")
for i, v := range arr {
for j, v2 := range v {
fmt.Printf("arr[%v][%v]=%v\t", i, j, v2)
}
fmt.Println()
}
}
代码输出内容：
============常规for循环==============
1 2 3
4 5 6
============for range循环==============
arr[0][0]=1 arr[0][1]=2 arr[0][2]=3
arr[1][0]=4 arr[1][1]=5 arr[1][2]=6
