数组的引入

【1】练习引入：

package main

import "fmt"
func main()  {
	score1 := 95
	score2 := 91
	score3 := 39
	score4 := 60
	score5 := 21
	sum := score1 + score2 + score3 + score4 +score5
	avg := sum / 5
	fmt.Printf("成绩的总和为：%v，成绩的平均数为：%v",sum,avg)
}

缺点：

成绩变量定义个数太多，成绩管理费劲，维护费劲 ---》 将成绩找个地方存起来 ---》 数组

---》存储相同类型的数据

【2】数组解决练习：

    // 定义数组
	var scores [5] int
	scores[0] = 95
	scores[1] = 91
	scores[2] = 39
	scores[3] = 60
	scores[4] = 21
	sum := 0
	for i := 0;i < len(scores); i++ {
		sum += scores[i]
	}
	avg := sum / 5
	fmt.Printf("成绩的总和为：%v，成绩的平均数为：%v",sum,avg)

总结：

数组定义格式：

var 数组名 [数组大小]数据类型

例如：

var scores [5]int

赋值：

scores[0] = 95

scores[1] = 91

scores[2] = 39

scores[3] = 60

scores[4] = 21

内存分析

【1】代码：

package main

import "fmt"
func main()  {
	var arr [3]int16
	fmt.Println(len(arr))
	fmt.Println(arr)
	//证明arr中存储的是地址值：
	fmt.Printf("arr的地址为：%p 
",&arr)
	fmt.Printf("arr的地址为：%p 
",&arr[0])
	fmt.Printf("arr的地址为：%p 
",&arr[1])
	fmt.Printf("arr的地址为：%p 
",&arr[2])
}

运行结果：

【2】内存分析：

PS : 数组每个空间占用的字节数取决于数组类型

【3】赋值内存：（数组是值类型，在栈中开辟内存）

数组优点：访问/查询/读取 速度快

数组的遍历

【1】普通for循环

【2】键值循环

（键值循环） for range结构是Go语言特有的一种的迭代结构，在许多情况下都非常有用，for range 可以遍历数组、切片、字符串、map 及通道，for range 语法上类似于其它语言中的 foreach 语句，一般形式为：

for key, val := range coll {

...

}

注意：

（1）coll就是你要的数组

（2）每次遍历得到的索引用key接收，每次遍历得到的索引位置上的值用val

（3）key、value的名字随便起名 k、v key、value

（4）key、value属于在这个循环中的局部变量

（5）你想忽略某个值：用_就可以了：

代码：

package main

import "fmt"
func main()  {
	//实现的功能：给出五个学生的成绩，求出成绩的总和，平均数：
	//给出五个学生的成绩：--->数组存储：
	//定义一个数组：
	var scores [5]int
	//将成绩存入数组：(循环 + 终端输入)
	for i := 0; i < len(scores); i++ {
		fmt.Printf("请录入第%d个学生的成绩",i + 1)
		fmt.Scanln(&scores[i])
	}
	//展示一下班级的每个学生的成绩：（数组进行遍历）
	//方式1：普通for循环：
	for i := 0; i < len(scores); i++ {
		fmt.Printf("第%d个学生的成绩为：%d 
",i + 1,scores[i])
	}
	//方式2：for-range循环
	fmt.Println("------------------------------")
	for k,v := range scores {
		fmt.Printf("第%d个学生的成绩为：%d 
",k + 1,v)
	}
}

运行结果：

数组的初始化方式

package main

import "fmt"
func main()  {
	//第一种：
	var arr1 [3]int = [3]int{3,4,5}
	fmt.Println(arr1)
 	//第二种：
	var arr2 = [3]int{1,2,3}
	fmt.Println(arr2)
	//第三种：
	var arr3 = [...]int{7,8,9,0}
	fmt.Println(arr3)
	//第四种：
	var arr4 = [...]int{2:66,0:33,1:99,3:88}
	fmt.Println(arr4)
}

注意事项

【1】长度属于类型的一部分 ：

package main

import "fmt"
func main()  {
	var arr1 = [3]int{1,2,3}
	fmt.Printf("数组的类型为：%T 
",arr1)

	var arr2 = [6]int{1,2,3,9,7,8}
	fmt.Printf("数组的类型为：%T 
",arr2)
}

【2】Go中数组属值类型，在默认情况下是值传递，因此会进行值拷贝。

package main

import "fmt"
func main()  {
	var arr1 = [3]int{1,2,3}
	fmt.Printf("数组的类型为：%T 
",arr1)

	var arr2 = [6]int{1,2,3,9,7,8}
	fmt.Printf("数组的类型为：%T 
",arr2)

	var arr3 = [3]int{3,6,9}
	test(arr3)
	fmt.Println("main():",arr3)
}

func test(arr [3]int)  {
	arr[0] = 7
	fmt.Println("test():",arr)
}

【3】如想在其它函数中，去修改原来的数组，可以使用引用传递(指针方式)。

    test2(&arr3)
	fmt.Println("main():",arr3)

func test2(arr *[3]int)  {
	(*arr)[0] = 7
	fmt.Println("test2():",arr)
}

二维数组

【1】二维数组的定义，并且有默认初始值：

package main

import "fmt"
func main()  {
	// 定义二维数组
	var arr [2][3]int
	fmt.Println(arr)
}

【2】二维数组内存：

    fmt.Printf("arr的地址是：%p 
",&arr)
	fmt.Printf("arr[0]的地址是：%p 
",&arr[0])
	fmt.Printf("arr[0][0]的地址是：%p 
",&arr[0][0])

	fmt.Printf("arr[1]的地址是：%p 
",&arr[1])
	fmt.Printf("arr[1][0]的地址是：%p 
",&arr[1][0])

【3】赋值操作：

    arr[0][1] = 47
	arr[0][0] = 82
	arr[1][1] = 25
	fmt.Println(arr)

【4】二维数组的初始化：

    // 初始化操作
	var arr1 [2][3]int = [2][3]int{{1,3,5},{2,4,6}} 
	fmt.Println(arr1)

二维数组的遍历

【1】普通for循环

【2】键值循环（for range）

代码：

package main

import "fmt"
func main()  {
	//定义二维数组：
	var arr [3][3]int = [3][3]int{{1,3,5},{2,4,6},{8,9,0}}
	fmt.Println(arr)
	fmt.Println("------------------------------")
	//方式1：普通for循环：
	for i := 0; i < len(arr); i++ {
		for j := 0; j < len(arr[i]); j++ {
			fmt.Print(arr[i][j],"	")
		}
		fmt.Println()
	}
	//方式2：for range循环：
	for key, value := range arr {
		for k, v := range value {
			fmt.Printf("arr[%v][%v]=%v	",key,k,v)
		}
		fmt.Println()
	}
}

参考源码：「链接」

参考个人博客：cyz