Go语言数组

1. 为什么需要数组

看一个问题

一个养鸡场有6只鸡，它们的体重分别是3kg、5kg、1kg、3.4kg、2kg、50kg。请问这六只鸡的总体重是多少？平均体重是多少？

传统的方法：

  1. 使用传统的方法不利于数据的管理和维护
  2. 传统的方法不够灵活，我们需要学习新的数据类型–>数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

// 思路分析：定义6个变量，分别表示6只鸡的，然后求出和，然后求出平均值
func main() {
	n1 := 3.0
	n2 := 5.0
	n3 := 1.0
	n4 := 3.4
	n5 := 2.0
	n6 := 50.0
	totalweight := n1 + n2 + n3 + n4 + n5 + n6
	//将totalweight处以6四舍五入保留两位小数
	avgweight := fmt.Sprintf("%.2f", totalweight/6)
	fmt.Printf("总体重=%v\n平均体重=%v\n", totalweight, avgweight)
}
/*
总体重=64.4
平均体重=10.73
*/

2. 什么是数组

数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或者多个元素组成。因为数组的长度是固定的，所以在go语言中很少直接使用数组。数组可以存放多个同一类型的数据。数组也是一种数据类型，在go中，数组是值类型。

image-20240516102409681

2.1 数组的定义

1
var 数组变量名 [元素数量] Type

说明：

数组变量名：数组声明及使用时的变量名

元素数量：数组的元素数量

Type：可以是任意基本类型，包括数组本身，类型为数组本身的时候，可以实现多维数组

数组的每个元素都可以通过索引下标来访问，索引下标的范围是从0开始到数组长度减1的位置，内置函数len()可以返回数组中元素的个数

2.2 初始化数组

初始化数组中{}中的元素不能大于[]中的数字

如果忽略[]中的数字不设置数组的大小，go语言会根据元素的个数来设置数组的大小

1
2
//取出数组中的第五个元素，它的值是50
balance[4]=50.0

方式一：

1
var balance = [5]float32{1000.0,2.0,3.4,7.0,50.0}

方式二：通过类型推导在声明数组的同时快速初始化数组

1
balance := [5]float32{1000.0,2.0,3.4,7.0,50.0}

方式三：如果数组长度不确定，可以使用…代替数组的长度，编译器会根据元素的个数自行推断数组的长度

1
2
3
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
2
3
//将索引为1和3的元素初始化
balance := [5]float32{1:2.0,3:7.0}
//第二个元素对应的值是2.0，第四个元素对应的值是7.0，其他的没有进行赋值

2.3 访问数组元素

数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值。

1
2
//读取了数组balance中第10个元素的值
var salary float32 = balance[9]

2.4 遍历数组

for...range遍历，这是go语言一种独有的结构，可以用来遍历访问数组的元素

1
2
3
for index,value :=range array01{
  ...
}
  1. 第一个返回值index是数组的下标
  2. 第二个value是该下标位置的值
  3. 他们都是仅在for循环内部可见的局部变量
  4. 遍历数组元素的时候，如果不想使用下标index，可以直接把下标index标为下划线
  5. index和value的名称不是固定的，可以自行制定，一般命名为index和value
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

func main() {
	sanguo_heroes := [...]string{"刘备", "关羽", "张飞"}
	for i, v := range sanguo_heroes {
		fmt.Printf("i=%v,v=%v\n", i, v)
		fmt.Printf("sanguo_heroes[%d]=%v\n", i, sanguo_heroes[i])
	}
	for _, v := range sanguo_heroes {
		fmt.Printf("元素的值=%v\n", v)
	}
}

/*
i=0,v=刘备
sanguo_heroes[0]=刘备
i=1,v=关羽
sanguo_heroes[1]=关羽
i=2,v=张飞
sanguo_heroes[2]=张飞
元素的值=刘备
元素的值=关羽
元素的值=张飞
*/

2.5 案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import "fmt"

func main() {
	var n [10]int
	var i, j int
	for i = 0; i < 10; i++ {
		n[i] = i + 100
	}
	for j = 0; j < 10; j++ {
		fmt.Printf("Element[%d]=%d\n", j, n[j])
	}
}

/*
Element[0]=100
Element[1]=101
Element[2]=102
Element[3]=103
Element[4]=104
Element[5]=105
Element[6]=106
Element[7]=107
Element[8]=108
Element[9]=109
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main

import "fmt"

func main() {
	var i, j, k int
	balance := [5]float32{10000.0, 2.0, 3.4, 7.0, 50.0}
	for i = 0; i < 5; i++ {
		fmt.Printf("balance[%d]=%f\n", i, balance[i])
	}
	balance2 := [...]float32{10000.0, 2.0, 3.4, 7.0, 50.0}
	for j = 0; j < 5; j++ {
		fmt.Printf("balance2[%d]=%f\n", j, balance2[j])
	}
	balance3 := [5]float32{1: 2.0, 3: 7.0}
	for k = 0; k < 5; k++ {
		fmt.Printf("balance3[%d]=%f\n", k, balance3[k])
	}
}

/*
balance[0]=10000.000000
balance[1]=2.000000
balance[2]=3.400000
balance[3]=7.000000
balance[4]=50.000000
balance2[0]=10000.000000
balance2[1]=2.000000
balance2[2]=3.400000
balance2[3]=7.000000
balance2[4]=50.000000
balance3[0]=0.000000
balance3[1]=2.000000
balance3[2]=0.000000
balance3[3]=7.000000
balance3[4]=0.000000
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package main

import "fmt"

// 创建一个byte类型的26个元素的数组，分别放置'A'-'Z'
// 使用for循环访问所有元素并打印出来。提示，字符数据运算'A'+1-->'B'
// 思路
// 1.声明一个数组var myChars [26]byte
// 2.使用for循环，利用字符可以进行运算的特点来赋值
// 3.使用for打印即可
func main() {
	var myChar [26]byte
	for i := 0; i < 26; i++ {
		myChar[i] = 'A' + byte(i)
		fmt.Printf("%c", myChar[i])
	}
	//求出一个数组的最大值，并得到对应的下标
	//思路
	//1. 声明一个数组var intArr[5]=[...]int {1,-1,9,10,11}
	//2.假定第一个元素就是最大值，下标就是0
	//3.然后从第二个元素开始循环比较，如果发现有更大的，则进行交换
	fmt.Println()
	intArr := [...]int{1, -1, 9, 90, 11, 9000}
	maxVal := intArr[0]
	maxValindex := 0
	for i := 1; i < len(intArr); i++ {
		if maxVal <= intArr[i] {
			maxVal = intArr[i]
			maxValindex = i
		}
	}
	fmt.Printf("maxVal=%v\nmaxValindex=%v\n", maxVal, maxValindex)

	//请求出一个数组的和和平均值
	//思路
	//1.就是声明一个数组 var intArr[5] = [...]int {1,-1,9,90,11}
	//2.求出和sum
	//3.求出平均值
	var intArr2 [5]int = [...]int{1, -1, 9, 90, 11}
	sum := 0
	for _, val := range intArr2 {
		sum += val
	}
	fmt.Printf("sum=%v\n平均值=%v\n", sum, float64(sum)/float64(len(intArr2)))
}

/*
ABCDEFGHIJKLMNOPQRSTUVWXYZ
maxVal=9000
maxValindex=5
sum=110
平均值=22
*/
go
go

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！