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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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:[e-mail]
*/

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個成員