Golang语言之数组(array)快速入门篇
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
目录
一.数组的定义
1.数组的引入
package main
import "fmt"
func main() {
// 实现的功能，将西游记师徒四人的分数求和，平均数
tangsanzang := 100
sunwukong := 99
zhubajie := 88
shaheshang := 77
// 求和
sum := tangsanzang + sunwukong + zhubajie + shaheshang
// 求平均数
avg := sum / 4
fmt.Printf("西游记师徒四人的总分: %d, 平均成绩: %d\n", sum, avg)
// 上述代码有个缺点，分数变量个数定义太多，不利于项目维护。
}
2.数组的概述
数组(array)是同一种数据类型元素的集合，其有以下3个特点:
- 1.长度固定;
- 2.连续内存空间;
- 3.同一类型集合;
在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。
定义数组的语法:
var 数组变量名 [元素数量]T
温馨提示:
数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。
3.数组案例
package main
import "fmt"
func main() {
// 定义一个长度为4的数组
var xiyouji [4]int
// 使用一个变量就可以进行存储
xiyouji[0] = 100
xiyouji[1] = 99
xiyouji[2] = 88
xiyouji[3] = 77
// 求和
sum := 0
for i := 0; i < len(xiyouji); i++ {
sum += xiyouji[i]
}
// 求平均数
avg := sum / len(xiyouji)
fmt.Printf("成绩的总和: %v, 成绩的平均数: %v\n", sum, avg)
}
4.数组的内存分析
package main
import "fmt"
func main() {
// 声明长度为5的数组
var array [5]uint16
// 数组赋值
array[0] = 100
array[1] = 200
array[2] = 300
// 获取数组的长度
fmt.Printf("数组长度为:%d,数组的内容:%v\n", len(array), array)
// 数组中存储的地址
fmt.Printf("数组的地址:%p\n", &array)
// 第一个空间的地址
fmt.Printf("数组的第一个地址:%p\n", &array[0])
// 第二个空间的地址
fmt.Printf("数组的第二个地址:%p\n", &array[1])
// 第三个空间的地址
fmt.Printf("数组的第三个地址:%p\n", &array[2])
// 第四个空间的地址
fmt.Printf("数组的第二个地址:%p\n", &array[3])
// 第五个空间的地址
fmt.Printf("数组的第三个地址:%p\n", &array[4])
}
5.四种数组初始化的方式
package main
import "fmt"
func main() {
var (
// 第一种： 带数组类型初始化列表
array01 [7]string = [7]string{"北京", "上海", "深圳", "西安", "成都", "杭州", "乌兰察布"}
// 第二种: 不带数组类型初始化列表
array02 = [4]bool{false, true, true}
// 第三种: 自行推断长度
array03 = [...]uint8{11, 22, 33, 44, 55}
// 第四种: 指定索引值
array04 = [...]int{1: 100, 3: -200, 5: 300}
)
fmt.Printf("array01类型: %T，值: %v, 长度: %d\n", array01, array01, len(array01))
fmt.Printf("array02类型: %T，值: %v, 长度: %d\n", array02, array02, len(array02))
fmt.Printf("array03类型: %T，值: %v, 长度: %d\n", array03, array03, len(array03))
fmt.Printf("array04类型: %T，值: %v, 长度: %d\n", array04, array04, len(array04))
}
二.数组的遍历
1.数组遍历的方式
数组的遍历方式有两种，即普通for循环和键值循环。
键值循环(for range)是GO语言特有的一种迭代结构，在许多情况下都非常有用，for range看了眼遍历数组，切片，字符串，map即通道。
for range语法上类似于其他语言中的foreach语句，一般形式如下:
for key,value := range 数组标识符 {
...
}
温馨提示:
1.数组标识符就是你定义的数组变量;
2.每次遍历得到的索引用key接收，每次遍历得到的索引位置上的值用value接收;
3.key,value的名称是随便起名，比如可以写成类似: "k,v"等;
4.key,value属于局部变量，每次变量都被修改了数据;
5.key,value的值如何你想忽略的话，接受的时候使用"_"代替即可;
2.for循环遍历
package main
import "fmt"
func main() {
// 功能实现: 手动录入3个学生的分数，然后打印出来。
var scores [3]int
// 将分数存储在数组中:
for i := 0; i < len(scores); i++ {
fmt.Printf("请录入第[%d]个学生的成绩: ", i+1)
fmt.Scanln(&scores[i])
}
// 使用for循环展示分数
for i := 0; i < len(scores); i++ {
fmt.Printf("第[%d]个学生的成绩为: %d\n", i+1, scores[i])
}
}
2.for range遍历
package main
import "fmt"
func main() {
// 功能实现: 手动录入3个学生的分数，然后打印出来。
var scores [3]int
// 将分数存储在数组中:
for i := 0; i < len(scores); i++ {
fmt.Printf("请录入第[%d]个学生的成绩: ", i+1)
fmt.Scanln(&scores[i])
}
// 使用for-range循环展示分数
for index, value := range scores {
fmt.Printf("第[%d]个学生的成绩为: %d\n", index+1, value)
}
}
三.数组的注意事项
1.数组长度属于类型的一部分
package main
import "fmt"
func main() {
var (
// 数组长度属于类型的一部分
array01 = [3]int{3, 5, 7}
array02 = [5]int{11, 22, 33, 44, 55}
)
fmt.Printf("array01数组的类型为: %T，数据为: %v\n", array01, array01)
fmt.Printf("array02数组的类型为: %T，数据为: %v\n", array02, array02)
}
2.数组属于值类型，默认进行值传递
package main
import "fmt"
func setName(name [3]string) {
name[0] = "JasonYin"
fmt.Printf("in setName ... name = %v\n", name)
}
func main() {
/*
数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。
温馨提示:
(1)数组支持"=="、"!="操作符，因为内存总是被初始化过的;
(2)"[n]*T"表示指针数组，"*[n]T"表示数组指针;
*/
var names = [3]string{"尹正杰", "yinzhengjie", "jasonyin2020"}
fmt.Printf("调用setName前: in main ... names = %v\n", names)
// 调用setName函数时，传递的数组属于值传递，因此setName内的修改并不会影响到main函数的数组
setName(names)
fmt.Printf("调用setName后: in main ... names = %v\n", names)
}
3.数组实现引用传递
package main
import "fmt"
// 接受的形参类型变为指针类型
func setName(name *[3]string) {
// 取出指针的地址存储的数组地址，基于数组的内存地址修改数据
(*name)[0] = "JasonYin"
fmt.Printf("in setName ... name = %v，地址: %p\n", name, name)
}
func main() {
var names = [3]string{"尹正杰", "yinzhengjie", "jasonyin2020"}
fmt.Printf("调用setName前: in main ... names = %v，地址: %p\n", names, &names)
// 传入names数组的地址
setName(&names)
fmt.Printf("调用setName后: in main ... names = %v，地址: %p\n", names, &names)
}
四.多维数组
1.字符串二维数组案例
package main
import (
"fmt"
)
func main() {
// 定义二维数组，如果有元素默认进行初始化赋值，则有默认值("零值")
address := [5][2]string{
{"陕西省", "西安市"},
{"河北省", "石家庄市"},
{"黑龙江省", "哈尔滨"},
{"江苏省", "南京市"},
}
fmt.Println(address)
// 支持索引取值
fmt.Println(address[2][1])
}
2.二维数组的内存分析
package main
import "fmt"
func main() {
// 定义二维数组，有默认的初始值
var array [2][3]uint16
// 二维数组赋值
array[0][0] = 100
array[0][1] = 200
array[1][1] = 300
fmt.Printf("array地址: %p\n", &array)
fmt.Printf("array[0]地址: %p\n", &array[0])
fmt.Printf("array[0][0]地址: %p\n", &array[0][0])
fmt.Printf("array[1]地址: %p\n", &array[1])
fmt.Printf("array[1][0]地址: %p\n", &array[1][0])
fmt.Printf("array[1][2]地址: %p\n", &array[1][2])
}
3.二维数组的三种数组初始化的方式
package main
import "fmt"
func main() {
var (
// 第一种： 带数组类型初始化列表
array01 [5][2]string = [5][2]string{
{"陕西省", "西安市"},
{"河北省", "石家庄市"},
{"黑龙江省", "哈尔滨"},
{"江苏省", "南京市"},
}
// 第二种: 不带数组类型初始化列表
array02 = [4][2]bool{
{true, false},
{true, true},
{false, false},
}
// 第三种: 自行推断长度，多维数组只有第一层可以使用"..."来让编译器推导数组长度。
array03 = [...][3]uint8{
{1, 4, 7},
{2, 5, 8},
{3, 6, 9},
{11, 22, 33},
{44, 55, 66},
{77, 88, 99},
}
// 不支持多维数组的内层使用"..."，会编译报错: "invalid use of [...] array (outside a composite literal)"
// array03 = [3][...]uint8{
// {11, 22, 33},
// {44, 55, 66},
// {77, 88, 99},
// }
)
fmt.Printf("array01类型: %T，值: %v, 长度: %d\n", array01, array01, len(array01))
fmt.Printf("array02类型: %T，值: %v, 长度: %d\n", array02, array02, len(array02))
fmt.Printf("array03类型: %T，值: %v, 长度: %d\n", array03, array03, len(array03))
}
五.二维数组的遍历
1.基于for循环遍历
package main
import "fmt"
func main() {
// 定义二维数组
var city = [...][3]string{
{"西安", "安康", "渭南"},
{"石家庄", "邯郸", "保定"},
{"郑州", "洛阳", "南阳"},
}
// 通过for循环遍历
for i := 0; i < len(city); i++ {
for j := 0; j < len(city[i]); j++ {
fmt.Print(city[i][j], "\t")
}
fmt.Println()
}
}
2.for range遍历
package main
import "fmt"
func main() {
// 定义二维数组
var province = [...][3]string{
{"西安", "安康", "渭南"},
{"石家庄", "邯郸", "保定"},
{"郑州", "洛阳", "南阳"},
}
// 通过for-range循环遍历
for index, city := range province {
for key, value := range city {
fmt.Printf("province[%d][%v] = %v\t\t", index, key, value)
}
fmt.Println()
}
}
六.练习题
1.将10以内的奇数放在同一个数组中并求和
package main
import (
"fmt"
)
func main() {
// 题意: 将10以内的奇数放在同一个数组中并求和
numberList := [5]int{1, 3, 5, 7, 9}
var sum int
for _, v := range numberList {
sum += v
}
fmt.Println(sum)
}
2.找出数组中和为指定值的两个元素的下标
package main
import (
"fmt"
)
func main() {
// 找出数组中和为指定值的两个元素的下标，从数组[1,3,5,7,8]中找出和为8的两个元素元素的下标。
// 需求分析:
// (1)一次取出每个元素;
// (2)计算一下: other = 8 - 当前值;
// (3)上一步计算出other的值后再和现有数组的元素进行比较，若存在就打印出来
numberList := [5]int{1, 3, 5, 7, 8}
for k1, v1 := range numberList {
other := 8 - v1
// 假设当前的索引是k1，则那另一个数字比较时选择索引位置加一即可。
for k2 := k1 + 1; k2 < len(numberList); k2++ {
if numberList[k2] == other {
fmt.Println(k1, k2)
}
}
// 采用下面的循环方式会重复取索引哟~
// for k2, v2 := range numberList {
// if other == v2 {
// fmt.Println(k1, k2)
// }
// }
}
}
本文来自博客园，作者：尹正杰，转载请注明原文链接：https://www.cnblogs.com/yinzhengjie/p/18319971，个人微信: "JasonYin2020"（添加时请备注来源及意图备注，有偿付费）
当你的才华还撑不起你的野心的时候，你就应该静下心来学习。当你的能力还驾驭不了你的目标的时候，你就应该沉下心来历练。问问自己，想要怎样的人生。
