GO ——奇妙的数组

GO 数组

1，声明数组

2，初始化数组

3，访问数组元素

4，多维数组

5，向函数中传递数组

GO 数组

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。相对于去声明number0, number1, ... number99的变量，使用数组形式numbers[0], numbers[1] ... numbers[99]更加方便且易于扩展。数组元素可以通过索引(位置)来读取(或者修改) ,索引从0开始,第一个元素索引为0,第二-个索引为1,以此类推。

1，声明数组

声明需要指定元索类型及元索个数，语法格式如下: .

var variable_ name[SIZE] variable type名字      长度     类型
如：var aaa [10] int

以上为-维数组的定义方式。例如以下定义了数组balance长度为10类型为float32:

var balance [10] float32

2，初始化数组

var balance = [5]float32{1000.0, 2.0, 3.4，7.0，50. 0}

可以通过字面量在声明数组的同时快速初始化数组:

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 := [...]float32{1000.0， 2.0, 3.4, 7.0，50.0}

如果设置了数组的长度，还可以通过指定下标来初始化元素:

//1将索引为1和3的元素初始化
balance := [5]float32(1:2.0,3:7.0}

初始化数组中{}中的元素个数不能大于[ ]中的数字。如果忽略[ ]中的数字不设置数组大小，Go会根据元素的个数来设置数组的大小

balance[4] = 50.0

以上实例读取了第五个元素，数组元素可以用过索引（位置）来读取或者修改，索引从0开始，第一个元素的索引下标是0，第二个索引是1，往后依次递增。第五个元素的索引就是4。

package main

import "fmt"

//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[9])//数组元素的遍历for i := 0; i < 10; i++ {fmt.Printf("%d ", aaa[i])}
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
10
1 2 3 4 5 6 7 8 9 10
[Done] exited with code=0 in 0.573 seconds

package main

import "fmt"

//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8}

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[9])//数组元素的遍历for i := 0; i < 10; i++ {fmt.Printf("%d ", aaa[i])}
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
0
1 2 3 4 5 6 7 8 0 0 //未赋值时是默认值
[Done] exited with code=0 in 0.577 seconds

package main

import "fmt"

//数组定义         元素，下标
var aaa = [10]int{1, 2, 3, 4, 5, 6, 7, 8}

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[9])//数组元素的遍历for i := 0; i < 10; i++ {fmt.Printf("%d ", aaa[i])}//输出数组长度fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
0
1 2 3 4 5 6 7 8 0 0 数组的长度： 10

[Done] exited with code=0 in 0.582 seconds

package main

import "fmt"

//数组定义         元素，下标
var aaa = []int{1, 2, 3, 4, 5, 6, 7, 8} //未标注下标

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[6])//数组元素的遍历for i := 0; i < 10; i++ {fmt.Printf("%d ", aaa[i])}//输出数组长度fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 panic: runtime error: index out of range [8] with length 8 //会报错

goroutine 1 [running]:
main.main()f:/goProject/src/dev_code/day9/example3/main/main.go:14 +0x1d1
exit status 2

package main

import "fmt"

//数组定义         元素，下标
var aaa = [...]int{1, 2, 3, 4, 5, 6, 7, 8} //长度定为...是不定长度的设定

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[6])//数组元素的遍历for i := 0; i < len(aaa); i++ {fmt.Printf("%d ", aaa[i])}//输出数组长度fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 数组的长度： 8   //定义了几个元素就是几个元素

[Done] exited with code=0 in 0.57 seconds

定义指定下标的值

package main

import "fmt"

//数组定义         元素，下标
var aaa = [6]int{1: 20, 3: 50}

func main() {//数组元素的遍历for i := 0; i < len(aaa); i++ {fmt.Printf("%d ", aaa[i])}//输出数组长度fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
0 20 0 50 0 0 数组的长度： 6

[Done] exited with code=0 in 0.6 seconds

示例：

package main

import "fmt"

//控制台输入10名学生的成绩，如果低于60分的，自动修正成绩为60，
//并且展现成绩清单
var a [10]int

func main() {//数组，学生成绩输入for i := 1; i <= 10; i++ {fmt.Printf("请输入第%d名学生的成绩:", i)fmt.Scan(&a[i-1])if a[i-1] < 60 {a[i-1] = 60}}//数组，学生成绩输出for j := 0; j < len(a); j++ {fmt.Printf("第%d名学生的成绩是%d.\n", j+1, a[j])}

}

PS F:\goProject\src\dev_code\day9\exampple4\main> go run .\main.go
请输入第1名学生的成绩:20
请输入第2名学生的成绩:30
请输入第3名学生的成绩:40
请输入第4名学生的成绩:50
请输入第5名学生的成绩:60
请输入第6名学生的成绩:55
请输入第7名学生的成绩:70
请输入第8名学生的成绩:80
请输入第9名学生的成绩:90
请输入第10名学生的成绩:100
第1名学生的成绩是60.
第2名学生的成绩是60.
第3名学生的成绩是60.
第4名学生的成绩是60.
第5名学生的成绩是60.
第6名学生的成绩是60.
第7名学生的成绩是70.
第8名学生的成绩是80.
第9名学生的成绩是90.
第10名学生的成绩是100.

3，访问数组元素

数组元素可以通过索引(位置)来读取。格式为数组名后加中括号,中括号中为索引的值。例如:

var salary float32 =balance[9 ]

以上实例读取了数组balance第10个元素的值。

示例：

package main

import "fmt"

//数组定义         元素，下标
var aaa = [...]int{1, 2, 3, 4, 5, 6, 7, 8} //长度定为...是不定长度的设定

func main() {//数组元素的提取，依赖下标提取fmt.Println(aaa[0]) //索引从0开始fmt.Println(aaa[6])//数组元素的遍历for i := 0; i < len(aaa); i++ {fmt.Printf("%d ", aaa[i])}//输出数组长度fmt.Println("数组的长度：", len(aaa))
}
[Running] go run "f:\goProject\src\dev_code\day9\example3\main\main.go"
1
7
1 2 3 4 5 6 7 8 数组的长度： 8   //定义了几个元素就是几个元素

[Done] exited with code=0 in 0.57 seconds

示例：

package main

import "fmt"

func main() {var i, j, k int//声明数组的同时快速初始化数组aaa := [5]float32{00, 0.2, 100, 7.4, 3.0}//输出数组元素for i = 0; i < 5; i++ {fmt.Printf("aaa[%d]=%f\n", i, aaa[i])}aaa2 := [...]float32{00, 0.2, 100, 7.4, 3.0}//输出每个数组元素的值for j = 0; j < 5; j++ {fmt.Printf("aaa2[%d]=%f\n", j, aaa2[j])
}//将索引为1和3的元素初始化aaa3 := [5]float32{00, 0.2, 100, 7.4, 3.0}
for k = 0; k < 5; k++ {fmt.Printf("aaa3[%d]=%f\n", k, aaa3[k])}

}

[Running] go run "f:\goProject\src\dev_code\day10\example1\main\main.go"
aaa[0]=0.000000
aaa[1]=0.200000
aaa[2]=100.000000
aaa[3]=7.400000
aaa[4]=3.000000
aaa2[0]=0.000000
aaa2[1]=0.200000
aaa2[2]=100.000000
aaa2[3]=7.400000
aaa2[4]=3.000000
aaa3[0]=0.000000
aaa3[1]=0.200000
aaa3[2]=100.000000
aaa3[3]=7.400000
aaa3[4]=3.000000

最大值/最小值求值

package main

import "fmt"

//用随意输入5个数值，输出最大值
func main() {var (tmp int //擂台sum intnum [5]int //名单)for i := 0; i < 5; i++ {fmt.Printf("请输入第%d个数字:", i+1)fmt.Scan(&sum)//人员添加到名单中num[i] = sum}fmt.Println("数据输入完成")//第一个数值登上擂台tmp = num[0]for j := 0; j < 5; j++ {//打擂比较最大值：最小值改为<就好了if num[j] > tmp {tmp = num[j]} else {continue}}fmt.Println("最大值：", tmp)

}
PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字:55
请输入第2个数字:22
请输入第3个数字:65
请输入第4个数字:85
请输入第5个数字:12
数据输入完成
最大值： 85

冒泡排序

package main

import "fmt"

//冒泡排序
func main() {var (num [5]intsum int)for i := 0; i < 5; i++ {fmt.Printf("请输入第%d个数字", i+1)fmt.Scan(&num[i])}//外循环，比较的轮次for k := 1; k < 5; k++ {//内循环，交换数值最大的数值，换到最后for j := 0; j < 5-k; j++ {if num[j] > num[j+1] {sum = num[j+1]   //数值交换可以：num[j],num[j+1]=num[j+1],num[j]num[j+1] = num[j]num[j] = sum}}}fmt.Println(num)for l := 0; l < 5; l++ {fmt.Printf("第%d个数值是%d\n", l+1, num[l])}

}

PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字12
请输入第2个数字2
请输入第3个数字56
请输入第4个数字78
请输入第5个数字53
[2 12 53 56 78]
第1个数值是2
第2个数值是12
第3个数值是53
第4个数值是56
第5个数值是78

示例：定义不定长数组添加元素

package main

import "fmt"

func main() {var (names []stringname  string)for i := 0; i < 5; i++ {fmt.Printf("请输入第%d个人的姓名", i+1)fmt.Scan(&name)//数组元素添加names = append(names, name)//使用追加的方式，追加到数组内fmt.Println("添加成功")}fmt.Println(names)
}
PS F:\goProject\src\dev_code\day10\example3\main> go run .\main.go
请输入第1个人的姓名ll
添加成功
请输入第2个人的姓名lo
添加成功
请输入第3个人的姓名lk
添加成功
请输入第4个人的姓名lm
添加成功
请输入第5个人的姓名lj
添加成功
[ll lo lk lm lj]

冒泡排序：定义不定长数组添加元素

package main

import "fmt"

//冒泡排序
func main() {var (num []intsum int)
for i := 0; i < 6; i++ {fmt.Printf("请输入第%d个数字", i+1)fmt.Scan(&sum)num = append(num, sum) //使用追加的方式，追加到数组内}//外循环，比较的轮次for k := 1; k < len(num); k++ {//内循环，交换数值最大的数值，换到最后for j := 0; j < len(num)-k; j++ {if num[j] > num[j+1] {num[j], num[j+1] = num[j+1], num[j]}}}fmt.Println(num)for l := 0; l < len(num); l++ {fmt.Printf("第%d个数值是%d\n", l+1, num[l])}
}
PS F:\goProject\src\dev_code\day10\example2\main> go run .\main.go
请输入第1个数字23
请输入第2个数字25
请输入第3个数字68
请输入第4个数字1
请输入第5个数字26
请输入第6个数字3
[1 3 23 25 26 68]
第1个数值是1
第2个数值是3
第3个数值是23
第4个数值是25
第5个数值是26
第6个数值是68

4，多维数组

多维数组声明方式:

var variable_ name [SIZE1][SIZE2]...[SIZEN] variable_ type
[1,2,3,4,5,6,7,8,9] 一维数组里面是元素.
[[1,2],[3,4],[5,6,7],[8,9]] 二维中有一维数组
[ [[1,2],[3,4]], [[5,6,7],[8,9]] ]三维有多少二维数组

以下实例声明了三维的整型数组

var threedim [5][10][4]int

二维数组

二维数组是最简单的多维数组，二维数组本质上是由- -维数组组成的。二维数组定义方式如下:

var arrayName [ x ][ y ] variable_ type

variable_ type 为数据类型, arrayName 为数组名,二维数组可认为是一个表格， x 为行，y为列，下图演示了一个二维数组a为三行四列:

示例：

package main

import "fmt"

//定义二位数组[[1,2,3],[4,5,6]]
func main() {//声明二位数组var nums [][]int//定义一维数组row1 := [3]int{1, 2, 3}row2 := [3]int{4, 5, 6}//一维数组作为元素添加到二位数组，使用append（）函数向空的二维数组添加两行一维数组nums = append(nums, row1[:])nums = append(nums, row2[:])fmt.Println("二维数组中的第一个元素：", nums[0])fmt.Println("二维数组中的第二个元素：", nums[1])fmt.Println("二维数组中第一个一维数组的第一个元素：", nums[0][0])

}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
二维数组中的第一个元素： [1 2 3]
二维数组中的第二个元素： [4 5 6]
二维数组中第一个一维数组的第一个元素： 1

[Done] exited with code=0 in 0.603 seconds

初始化二维数组

多维数组可通过大括号来初始值。以下实例为一个3行4列的二维数组:

a:=[3][4]int{
{0, 1, 2, 3}，/*第一行索引为0*/
{4, 5, 6，7}，/*第二行索引为1 */
{8, 9, 10, 11}， /*第三行索引为2 */

注意：

以上代码中倒数第二行的}必须要有逗号，因为最后一行的}不能单独一行，也可以写成这样: .

a := [3][4]int{
{o,1,2,3}，    /*声第一行索引为0 */
{4,5,6,7}，    /*第二行索引为1 */
{8，9, 10, 11}} /*第三行索引为2“/

示例:实例初始化一个2行2列的二维数组

package main

import "fmt"

func main() {//创建二维数组test := [2][2]string{}//向二维数组添加元素test[0][0] = "张三"test[0][1] = "张四"test[1][0] = "李三"test[1][1] = "李四"//显示结果fmt.Println(test)
}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
[[张三 张四] [李三 李四]]

[Done] exited with code=0 in 0.578 seconds

示例：

package main

import "fmt"

//定义二位数组[[1,2,3],[4,5,6]]
func main() {//初始化二维数组nums := [2][3]int{{1, 2, 3},{4, 5, 6},}
fmt.Println("二维数组中的第一个元素：", nums[0])fmt.Println("二维数组中的第二个元素：", nums[1])fmt.Println("二维数组中第一个一维数组的第一个元素：", nums[0][0])

}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
二维数组中的第一个元素： [1 2 3]
二维数组中的第二个元素： [4 5 6]
二维数组中第一个一维数组的第一个元素： 1

[Done] exited with code=0 in 0.563 seconds

访问二维数组

二维数组通过指定坐标来访问。如数组中的行索引与列索引，例如:实例访问了二维数组val第三行的第四个元素。

val := a[2][3]
或
var value int=a[2][3]

二维数组可以使用循环嵌套来输出元素：

package main

import "fmt"

func main() {//数组3行4列var a = [3][4]int{{1, 5, 2, 4}, {8, 4, 3, 9}, {7, 5, 1, 8}}//输出数组元素for i := 0; i < 3; i++ {for j := 0; j < 4; j++ {fmt.Printf("a[%d][%d]=%d\n", i, j, a[i][j])}}

}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
a[0][0]=1
a[0][1]=5
a[0][2]=2
a[0][3]=4
a[1][0]=8
a[1][1]=4
a[1][2]=3
a[1][3]=9
a[2][0]=7
a[2][1]=5
a[2][2]=1
a[2][3]=8

示例：

package main

import "fmt"

//定义二位数组[[1,2,3],[4,5,6]]
func main() {//初始化二维数组nums := [2][3]int{{1, 2, 3},{4, 5, 6},}//遍历二位数组中的每个元素//外层读行for i := 0; i < 2; i++ {//内层读列for j := 0; j < 3; j++ {fmt.Println(nums[i][j])}}

}
[Running] go run "f:\goProject\src\dev_code\day10\example4\main\main.go"
1
2
3
4
5
6

示例：创建各个维度元素数量不一致的多维数组

package main

import "fmt"

func main() {//创建空的二位数组value := [][]string{}//创建三个以为数组，各数组长度不一致test1 := []string{"张三", "张四", "张五"}test2 := []string{"李三"}test3 := []string{"王三", "王四"}//使用append()函数将一维数组添加进二维数组value = append(value, test1)value = append(value, test2)value = append(value, test3)//循环输出for i := range value {fmt.Printf("test:%d\n", i+1)fmt.Println(value[i])}

}
[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
test:1
[张三 张四 张五]
test:2
[李三]
test:3
[王三 王四]

[Done] exited with code=0 in 0.538 seconds

三维数组示例

package main

import "fmt"

func main() {//创建空的二位数组value := [][][]string{}value1 := [][]string{}value2 := [][]string{}//创建三个以为数组，各数组长度不一致test1 := []string{"张三", "张四", "张五"}test2 := []string{"李三"}test3 := []string{"王三", "王四"}test4 := []string{"赵二", "赵三"}//使用append()函数将一维数组添加进二维数组value1 = append(value1, test1)value1 = append(value1, test2)value2 = append(value2, test4)value2 = append(value2, test3)value = append(value, value1)value = append(value, value2)
fmt.Println("三维数组value=", value)//循环输出for i := range value {for j := range value {fmt.Printf("value[%d][%d]\n", i, j)fmt.Println(value[i][j])}}

}

[Running] go run "f:\goProject\src\dev_code\day10\example5\main\main.go"
三维数组value= [[[张三 张四 张五] [李三]] [[赵二 赵三] [王三 王四]]]
value[0][0]
[张三 张四 张五]
value[0][1]
[李三]
value[1][0]
[赵二 赵三]
value[1][1]
[王三 王四]

[Done] exited with code=0 in 0.533 seconds

5，向函数中传递数组

如果想向函数传递数组参数，需要在函数定义时，声明形参为数组，可以通过以下两种方式来声明:

方式一

形参设定数组大小：

void myFunction(param [10]int)
{
.
.
.
}

方式二

形参为设定数组大小：

void myFunction(param []int)
{
.
.
.
}

示例：函数接收者整型数组参数，另一个参数指定了数组元素的个数，并返回平均值：

package main

import ("fmt"
)

//定义数组
var num [5]int

func main() {num = [5]int{10, 20, 30, 40, 50}fmt.Println("元素的和为：", sum(num))
}

//数组传入
func sum(a [5]int) int {//求和的变量s := 0//求和过程for i := range a {s += a[i]}return s
}
[Running] go run "f:\goProject\src\dev_code\day10\example6\main\main.go"
元素的和为： 150

[Done] exited with code=0 in 0.557 seconds