golang第八天，數組

這是我參與8月更文挑戰的第8天，活動詳情查看：8月更文挑戰

什麼是數組

golang提供了數組類型的數據結構。數組是具備相同惟一類型的一組已編號且長度固定的數據項序列，這種類型能夠是任意的原始類型，例如（整形，字符串或者自定義類型）。

數組元素能夠經過索引（位置）來讀取（或者修改），索引從0開始，第一個元素索引爲0，第二個索引爲1，以此類推。（數組以 0 開始在全部類 C 語言中是類似的）數組的下標取值範圍是從0開始的，到長度減1

數組長度必須是一個常量表達式，而且必須是一個非負整數。數組長度也是數組類型的一部分，因此[5]int和[10]int是屬於不一樣類型的。

數組一旦定義後，大小不能更改（編譯時須要知道數組長度以便分配內存）。

總結：

• 數組是長度固定的數據類型
• 數據元素的類型相同
• 數組是從0開始的，一直到長度減1爲結束
• 數組長度是一個常量表達式，而且是一個非負整數

做用及應用場景

做用：組在內存中是連續的存儲空間，能夠有效的提高cpu的執行效率

應用場景：存儲多個相同類型的數據時，可使用數組

數組的定義和語法

一維數組的定義方式

初始化自定義

var arr [10] int
arr[0] = 100
arr[2] = 200
fmt.Println(arr)  // [100, 0, 200, 0, 0, 0, 0, 0, 0, 0]
複製代碼

初始賦值定義法

var arr [2] int = [2] int {1, 2}
for i := 0; i < len(arr); i++ {
    fmt.Println(i, arr[i])
}
複製代碼

注意：這裏有個坑，var arr[2] int = [2]int{ 1, 2 }, 是花括號，而不是中括號。。一開始我踩坑了。

不用定義長度，簡略賦值法

package main

import "fmt"

func main() {
	arr := [...]int{1, 2, 3, 4, 5}
	fmt.Println(arr)
}
複製代碼

注意，簡略賦值，不須要用var或者const聲明

二維數組

package main

import "fmt"

func main() {
    var arr1 [2][3]int
    fmt.Println(arr1)  // [[0 0 0] [0 0 0]]

    arr2 := [2][3]int{{1, 2, 4}, {3, 4, 3}}
    fmt.Println(arr2)  // [[1 2 4] [3 4 3]]

    arr3 := [4][3]int{1: {1, 1, 1}, 2: {2, 2, 2}}
    fmt.Println(arr3)  // [[0 0 0] [1 1 1] [2 2 2] [0 0 0]]
}
複製代碼

注意，這裏arr1不能使用 :=，會報type [2][3]int is not an expression,因爲[2][3]int這不是一個表達式

多維度，多個數組

初始定義

package main

import "fmt"

func main() {
    var arr [4][3][2]int = [4][3][2]int{}
    fmt.Println(arr)
    // [[[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]] [[0 0] [0 0] [0 0]]]
}
複製代碼

示例：

package main

import "fmt"

func main() {
    /*

    一維數組：存儲的多個數據是數值自己
        a1 :=[3]int{1,2,3}

    二維數組：存儲的是一維的一維
        a2 := [3][4]int{{},{},{}}

        該二維數組的長度，就是3。
        存儲的元素是一維數組，一維數組的元素是數值，每一個一維數組長度爲4。

    多維數組：。。。

     */
    a2 := [3][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}
    fmt.Println(a2)
    fmt.Printf("二維數組的地址：%p\n", &a2)
    fmt.Printf("二維數組的長度：%d\n", len(a2))

    fmt.Printf("一維數組的長度：%d\n", len(a2[0]))
    fmt.Println(a2[0][3]) // 4
    fmt.Println(a2[1][2]) //7
    fmt.Println(a2[2][1]) // 10

    //遍歷二維數組
    for i:=0;i<len(a2);i++{
        for j:=0;j<len(a2[i]);j++{
            fmt.Print(a2[i][j],"\t")
        }
        fmt.Println()
    }

    fmt.Println("---------------------")
    //for range 遍歷二維數組
    for key1,val1 := range a2{
        for key2,val2 := range arr{
            fmt.Print(val2,"\t")
        }
        fmt.Println()
    }
}
複製代碼

其餘類型的數組建立方式

var a [4] float32 // 等價於：var arr2 = [4]float32{}
  fmt.Println(a) // [0 0 0 0]
  var b = [5] string{"ruby", "王二狗", "rose"}
  fmt.Println(b) // [ruby 王二狗 rose  ]
  var c = [5] int{'A', 'B', 'C', 'D', 'E'} // byte
  fmt.Println(c) // [65 66 67 68 69]
  d := [...] int{1,2,3,4,5}// 根據元素的個數，設置數組的大小
  fmt.Println(d)//[1 2 3 4 5]
  e := [5] int{4: 100} // [0 0 0 0 100]
  fmt.Println(e)
  f := [...] int{0: 1, 4: 1, 9: 1} // [1 0 0 0 1 0 0 0 0 1]
  fmt.Println(f)
複製代碼

數組是值類型

golang中的數組是值類型，而不是引用類型。這意味着當它們被分配給一個新變量時，將把原始數組的副本分配給新變量，若是對新變量進行了更改，則不會在原始數組中反映

package main
import "fmt"
func main() {
    a := [...]string{"a", "b", "c"}
    b := a
    b[0] = "小阿肥"
    fmt.Println("a is: ", a)
    fmt.Println("b is: ", b)
}
複製代碼

數組的排序

數組的排序，就是讓一個數組中的數據，根據必定的算法，最終是數值有順序的，能夠從小到大(升序)，也能夠從大到小(降序)。默認是升序。

排序算法也有不少種，冒泡排序，選擇排序，插入排序，希爾排序，快速排序，堆排序等等。

倒序

arr := [5]int{15, 23, 8, 10, 7}
for i := 0; i < len(arr) - 1; i++ {
  if(arr[i] < arr[i + 1]) {
     t := arr[i]
     arr[i] = arr[i + 1]
     arr[i + 1] = t
  }
}
fmt.Println(arr)
複製代碼

數組的注意事項

• 數組是值類型
• len()獲取長度
• 數組的長度是數組類型的組成部分
• 數組在內存當中是連續的存儲空間
• 數組作爲參數以引用形式傳遞函數，意義重大，當傳遞較大的數組時能夠有效的提高cpu執行效率
• 數組作爲值類型來傳遞函數,調用時是值拷貝，若是較大的數組傳遞對cpu的效能消耗是極其大的

最後

剛學golang，但願你們監督而且一塊兒努力

有興趣的小夥伴，歡迎關注我訂閱號：EntrepreneurialG