GoLang基础数据类型--->数组（array）详解

　　　　　　　　　　　　　　　　　　 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个成员