GoLang基础数据类型--->数组（array）详解
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.Golang数组简介
数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。换句话说，与其他大多数语言类似，Go语言的数组也是一个元素类型相同的定长的序列。
二.定义数组
在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量表达式（常量表达式是指在编译期即可计算结果的表达式）。数组的长度是该数组类型的一个内置常量，可以用Go语言的内置函数len()来获取。
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import (
"strings"
"fmt"
"reflect"
) func main() {
var golang_array [5]string //定义一个长度为5的字符串数组。我们可以用一个定义数组的公式：“var golang_array [n]type ”, n表示数组长度，type表示数组存储类型。
line := "yinzhengjie is a good boy"
list := strings.Split(line, " ") //将字符串切割成相应的一个切片。
for k,v := range list{
golang_array[k] = v //将切片的每一个值赋值给我们刚刚定义的长度为5的数组。
}
fmt.Println(reflect.TypeOf(list)) //查看list的数据类型
fmt.Println(golang_array)
fmt.Println(reflect.TypeOf(golang_array))
} #以上代码执行结果如下：
[]string
[yinzhengjie is a good boy]
[5]string
三.常见的数组声明方法
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" type new struct {
x,y int64
} var (
Golang_bytes_array [10]byte //声明长度为5的数组，每个元素为一个字节；
Golang_pointer_array [5]*int //指针数组
Golang_two_dimensional_array [2][3]int //二维数组
Golang_three_dimensional_array [2][3][4]int //三维数组，等同于[2]([3]([4]int))
Golang_string_array [5]string //字符串数组
Golang_dynamic_array = [...]int{1,2,3,4} //这种方法需要进行赋值操作。
) func main() {
fmt.Println(Golang_bytes_array)
fmt.Println(Golang_pointer_array)
fmt.Println(Golang_two_dimensional_array)
fmt.Println(Golang_three_dimensional_array)
fmt.Println(Golang_string_array)
fmt.Println(Golang_dynamic_array)
} #以上代码执行结果如下：
[0 0 0 0 0 0 0 0 0 0]
[<nil> <nil> <nil> <nil> <nil>]
[[0 0 0] [0 0 0]]
[[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[0 0 0 0] [0 0 0 0] [0 0 0 0]]]
[ ]
[1 2 3 4]
四.数组初始化
1.二维数组初始化展示
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
Golang_two_dimensional_array := [2][5]string{{"a","b"},{"c","d"}} //进行初始化，当然还可以这样写：Golang_two_dimensional_array := [...][5]string{{"a","b"},{"c","d"}}
res := Golang_two_dimensional_array
for _,v := range res {
for x,y := range v{
fmt.Println(x,y)
}
}
fmt.Println(Golang_two_dimensional_array)
} #以上代码执行结果如下：
0 a
1 b
2
3
4
0 c
1 d
2
3
4
[[a b ] [c d ]]
2.多维数组初始化展示
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import (
"fmt"
) func main() {
Golang_Multidimensional_array := [...][3][10]string{ //该行效果等同于："Golang_Multidimensional_array := [3][3][10]string",这不过我那样写可以动态扩展，没有把参数写死。
{
{
"中华名族园","北京奥林匹克公园","国家体育馆","中国科学技术官","奥林匹克公园网球场","蟹岛绿色生态农庄","国家游泳中心（水立方）","中国紫檀博物馆","北京欢乐谷","元大都城",
},
{
"北京野生动物园","男孩子麋鹿苑","中华文化园","留民营生态农场","中国印刷博物馆","北普陀影视城","大兴滨河森林公园","呀路古热带植物园","庞各庄万亩梨园","西黄垈村",
},
{
"颐和园","北京大学","西山八大处","圆明园遗址公园","*广播电视塔","北京植物园","紫竹院公园","凤凰岭","香山公园","王渊潭",
},
},
{
{
"秦始皇兵马俑","大雁塔","大唐芙蓉园","华清池","黄巢堡国家森林公园","西安碑林博物馆","骊山国家森林公园","西安城墙","秦始皇陵","翠华山",
},
{
"中坝大峡谷","香溪洞","安康双龙生态旅游度假区","瀛湖生态旅游景区","简车湾休闲景区","南宫山","天书峡景区","汉江燕翔洞景区","飞渡峡-黄安坝景区","千层河",
},
{
"西柏坡红色旅游区","嶂石岩","天桂山","天山海世界","五岳塞","驼梁山","辛集国际皮革城","东方巨龟苑","白鹿温泉度假中心","灵寿秋山景区",
},
},
{
{
//此处的字符串未填写，感兴趣的朋友可以继续写下去；
},
{
//此处的字符串未填写，感兴趣的朋友可以继续写下去；
},
{
//此处的字符串未填写，感兴趣的朋友可以继续写下去；
},
},
} fmt.Println(Golang_Multidimensional_array) for i:=0;i<50 ;i++ {
fmt.Print("*")
}
fmt.Print("我是分割线")
for i:=0;i<50 ;i++ {
fmt.Print("*")
}
fmt.Println() for k,v := range Golang_Multidimensional_array{
fmt.Println(k,v)
//for x,y := range v{
// fmt.Println(x,y)
//}
}
} #以上代码执行结果如下：
[[[中华名族园 北京奥林匹克公园 国家体育馆 中国科学技术官 奥林匹克公园网球场 蟹岛绿色生态农庄 国家游泳中心（水立方） 中国紫檀博物馆 北京欢乐谷 元大都城] [北京野生动物园 男孩子麋鹿苑 中华文化园 留民营生态农场 中国印刷博物馆 北普陀影视城 大兴滨河森林公园 呀路古热带植物园 庞各庄万亩梨园 西黄垈村] [颐和园 北京大学 西山八大处 圆明园遗址公园 *广播电视塔 北京植物园 紫竹院公园 凤凰岭 香山公园 王渊潭]] [[秦始皇兵马俑 大雁塔 大唐芙蓉园 华清池 黄巢堡国家森林公园 西安碑林博物馆 骊山国家森林公园 西安城墙 秦始皇陵 翠华山] [中坝大峡谷 香溪洞 安康双龙生态旅游度假区 瀛湖生态旅游景区 简车湾休闲景区 南宫山 天书峡景区 汉江燕翔洞景区 飞渡峡-黄安坝景区 千层河] [西柏坡红色旅游区 嶂石岩 天桂山 天山海世界 五岳塞 驼梁山 辛集国际皮革城 东方巨龟苑 白鹿温泉度假中心 灵寿秋山景区]] [[ ] [ ] [ ]]]
**************************************************我是分割线**************************************************
0 [[中华名族园 北京奥林匹克公园 国家体育馆 中国科学技术官 奥林匹克公园网球场 蟹岛绿色生态农庄 国家游泳中心（水立方） 中国紫檀博物馆 北京欢乐谷 元大都城] [北京野生动物园 男孩子麋鹿苑 中华文化园 留民营生态农场 中国印刷博物馆 北普陀影视城 大兴滨河森林公园 呀路古热带植物园 庞各庄万亩梨园 西黄垈村] [颐和园 北京大学 西山八大处 圆明园遗址公园 *广播电视塔 北京植物园 紫竹院公园 凤凰岭 香山公园 王渊潭]]
1 [[秦始皇兵马俑 大雁塔 大唐芙蓉园 华清池 黄巢堡国家森林公园 西安碑林博物馆 骊山国家森林公园 西安城墙 秦始皇陵 翠华山] [中坝大峡谷 香溪洞 安康双龙生态旅游度假区 瀛湖生态旅游景区 简车湾休闲景区 南宫山 天书峡景区 汉江燕翔洞景区 飞渡峡-黄安坝景区 千层河] [西柏坡红色旅游区 嶂石岩 天桂山 天山海世界 五岳塞 驼梁山 辛集国际皮革城 东方巨龟苑 白鹿温泉度假中心 灵寿秋山景区]]
2 [[ ] [ ] [ ]]
3.先声明再初始化
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import (
"fmt"
"strings"
) var (
yinzhengjie [5]string //声明变量
) func main() {
str := "a,b,c,d,e"
list := strings.Split(str,",")
for k,v := range list{
yinzhengjie[k] = v //在上面通过“var”关键字提前声明了变量，现在我们只需要进行初始化就成。注意是没有加“：”哟！
}
fmt.Println(yinzhengjie)
} #以上代码执行结果如下：
[a b c d e]
4.直接声明并初始化
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
var a [2]int //先声明变量类型
a[0] = 100 //对已经声明的
b := [5]byte{'a','b','c','d','e'} //声明并初始化一个长度为“5”的字节（“uint8”）数组
c := [3]int{1,22,333}
d := [...]int{1,2,3,4} //可以省略长度而采用`...`的方式，Golang会自动根据元素个数来计算长度,
e := [...]int{10:666} //不指定长度，对第“11”个元素（下标为10）赋值“666”
f := [2][3]int{[3]int{1,2,3},[3]int{4,5,6}}
g := [2][3]int{{100,200,300},{400,500,500}} //如果内部的元素和外部的一样，那么上面的声明可以简化，直接忽略内部的，因为都是“int”型
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
fmt.Println(f)
fmt.Println(g)
} #以上代码执行结果如下：
[100 0]
[97 98 99 100 101]
[1 22 333]
[1 2 3 4]
[0 0 0 0 0 0 0 0 0 0 666]
[[1 2 3] [4 5 6]]
[[100 200 300] [400 500 500]]
5.数组的花式定义和赋值
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
var num [5]int //先定义一个容量为5的数组num。
num = [5]int{1,3,5,7,9} //给这num数组赋值
fmt.Printf("num数组的元素是:%d\n",num) var a [3]int = [3]int{1,2,3} //将一个容量为三长度也为3的数组赋值给另一个容量为三的数组.
fmt.Printf("a数组的元素是：%d\n",a)
fmt.Printf("a[1]所对应的值是：%d\n",a[1]) //表示取a数组下标对应是1的value.
fmt.Printf("a数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(a),len(a),(cap(a)-len(a))) //cap函数用于计算数组的容量，len函数用于计算数组的长度. b := [...]int{1,2,3,4} //这种定义方式其实就是不写具体的容量参数，那么容量的值就和长度是相等的。
fmt.Printf("b数组的元素是：%d\n",b)
fmt.Printf("该数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(b),len(b),(cap(b)-len(b))) c := [...]int{4:20,7:-1} //定义下标为4的值为20，下标为7的值为-1。给指定数组下标赋初值，数组的长度为最大下标的加1,如果一个数组没有写明容量的话，会根据其下标最大的元素来定义其容量和长度。
fmt.Printf("c数组的元素是：%d\n",c)
fmt.Printf("该数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(c),len(c),(cap(c)-len(c)))
} #以上代码执行结果如下：
num数组的元素是:[1 3 5 7 9]
a数组的元素是：[1 2 3]
a[1]所对应的值是：2
a数组的容量是：3，该容量的长度是:3,还可以存取0个成员
b数组的元素是：[1 2 3 4]
该数组的容量是：4，该容量的长度是:4,还可以存取0个成员
c数组的元素是：[0 0 0 0 20 0 0 -1]
该数组的容量是：8，该容量的长度是:8,还可以存取0个成员
五.数组访问方式
1.通过range访问
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
Number := [6]int{100,200,300,400,500,600}
for k,v := range Number{
fmt.Printf("Number[%d]=%d\n",k,v) //range具有两个返回值，第一个返回值i是元素的数组下标，第二个返回值v是元素的值。
}
} #以上代码执行结果如下：
Number[0]=100
Number[1]=200
Number[2]=300
Number[3]=400
Number[4]=500
Number[5]=600
2.通过for循环来访问
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
Number := [6]int{100,200,300,400,500,600}
for i := 0;i < len(Number) ;i++ {
fmt.Printf("Number[%d]=[%d]\n",i,Number[i])
}
} #以上代码执行结果如下：
Number[0]=[100]
Number[1]=[200]
Number[2]=[300]
Number[3]=[400]
Number[4]=[500]
Number[5]=[600]
六.数组进阶知识
1.数组的内存大小以及内存地址的查看
在Go语言中数组是一个值类型（value type）。是真真实实的数组，而不是一个指向数组内存起始位置的指针，也不能和同类型的指针进行转化，这一点严重不同于C语言。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。我们来看下面这个案例：
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import (
"fmt"
"unsafe"
) func main() {
Number := [...]int{100,200,300,400,500,600}
fmt.Printf("Number的元素是:%d\n",Number)
fmt.Printf("Number所占内存大小是：[%d]bytes\n",unsafe.Sizeof(Number)) //长度为“1”的数组所占内存大小是“8”字节。 var n1,n2 int64
n1 = 100
n2 = n1 //所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。知识把值给copy走了。
fmt.Printf("n1所对应的值是：[%d],n1的内存地址是：[%d]\n",n1,&n1)
fmt.Printf("n2所对应的值是：[%d],n2的内存地址是：[%d]\n",n2,&n2)
} #以上代码执行结果如下：
Number的元素是:[100 200 300 400 500 600]
Number所占内存大小是：[48]bytes
n1所对应的值是：[100],n1的内存地址是：[825741263336]
n2所对应的值是：[100],n2的内存地址是：[825741263344]
2.作用域-数组值传递
如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。当然，你也可以理解成作用域的不用，导致数据无法修改。更多关于Golang和C的数组区别可以点击这里：
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func Update(Golang_array [4]int) [4]int {
Golang_array[0] = 100
fmt.Printf("我在Update函数里面：Golang_array的值是%v\n",Golang_array)
return Golang_array
} func main() {
Golang_array := [...]int{1,2,3,4}
res := Update(Golang_array) //将Golang_array数组交给该函数处理。
fmt.Println("Update处理结果是:",res)
fmt.Printf("我在main函数里面：Golang_array的值是%v\n",Golang_array) //这里要注意的是，它在main函数中的作用域当中，所以它拿不到Update作用域的“Golang_array”
} #以上代码执行结果如下：
我在Update函数里面：Golang_array的值是[100 2 3 4]
Update处理结果是: [100 2 3 4]
我在main函数里面：Golang_array的值是[1 2 3 4]
3.查询数组的基本属性
/*
#!/usr/bin/env gorun
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
EMAIL:y1053419035@qq.com
*/ package main import "fmt" func main() {
var num [5]int //先定义一个容量为5的数组num。
num = [5]int{1,3,5,7,9} //给这num数组赋值
fmt.Printf("num数组的元素是:%d\n",num)
var a [3]int = [3]int{1,2,3} //将一个容量为三长度也为3的数组赋值给另一个容量为三的数组.
fmt.Printf("a数组的元素是：%d\n",a)
fmt.Printf("a[1]所对应的值是：%d\n",a[1]) //表示取a数组下标对应是1的value.
fmt.Printf("a数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(a),len(a),(cap(a)-len(a))) //cap函数用于计算数组的容量，len函数用于计算数组的长度.
b := [...]int{1,2,3,4} //这种定义方式其实就是不写具体的容量参数，那么容量的值就和长度是相等的。
fmt.Printf("b数组的元素是：%d\n",b)
fmt.Printf("该数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(b),len(b),(cap(b)-len(b)))
c := [...]int{4:20,7:-1} //定义下标为4的值为20，下标为7的值为-1。给指定数组下标赋初值，数组的长度为最大下标的加1,如果一个数组没有写明容量的话，会根据其下标最大的元素来定义其容量和长度。
fmt.Printf("c数组的元素是：%d\n",c)
fmt.Printf("该数组的容量是：%d，该容量的长度是:%d,还可以存取%d个成员\n",cap(c),len(c),(cap(c)-len(c)))
} #以上代码执行结果如下：
num数组的元素是:[1 3 5 7 9]
a数组的元素是：[1 2 3]
a[1]所对应的值是：2
a数组的容量是：3，该容量的长度是:3,还可以存取0个成员
b数组的元素是：[1 2 3 4]
该数组的容量是：4，该容量的长度是:4,还可以存取0个成员
c数组的元素是：[0 0 0 0 20 0 0 -1]
该数组的容量是：8，该容量的长度是:8,还可以存取0个成员