數組，切片和字典

一、數組（Array）

數組是一個有相同數據類型的元素組成的固定長度的有序集合，如：var x [5]int，使用var定義的數組，默認值若是整型爲0，浮點型爲0.0，字符串爲""，對象爲nil。

求整型數組之和，使用range函數，遍歷數組、切片、字典時，返回索引和元素值；當對某個返回值不感興趣時，要用下劃線（_）來代替

package main

import "fmt"

func main() {
    var x [5]int
    x[0] = 2
    x[1] = 3
    x[2] = 3
    var sum int
    for _, elem := range x {
        sum += elem
    }
    fmt.Println(sum)
}

定義數組其餘方式：1）、var x = [5]int{1,2,3,4,5}

　　　　　　　　　2）、var x =[5]int{}

　　　　　　　　　　　  x[0]=1

　　　　　　　　　3）、var x = [...]string{　　　　　　　　　　　　　　　　　var x = [...]string{
　　　　　　　　　　　　　　"Monday",　　　　　　　　　　　　　　　　　　　　"Monday",　

　　　　　　　　　　　　　　"Tuesday"　　　　　　　　　　　　　　　　　　　　"Tuesday",//能夠帶着英文逗號
　　　　　　　　　　　　}　　　　　　　　　　　　　　　　　　　　　　　　}

二、切片（Slice）

切片相似數組，切片長度是可變的；切片是有容量（capacity）和長度（length）兩個屬性的；切片變量使用時，索引不能大於等於切片長度，不然報錯out of range

1）、make函數定義切片

package main

import "fmt"

func main() {
    var x = make([]float64, 5) //切片的容量和長度都是5
    fmt.Println("Capacity:", cap(x), "Length:", len(x))
    var y = make([]float64, 5, 10) //切片容量爲10，長度爲5
    fmt.Println("Capacity:", cap(y), "Length:", len(y))

    for i := 0; i < len(x); i++ {
        x[i] = float64(i)
    }
    fmt.Println(x)

    for i := 0; i < len(y); i++ {
        y[i] = float64(i)
    }
    fmt.Println(y)
}

輸出如圖：

2）、經過數組切片賦值，採用[low_index:high_index]方式截取數組來獲取數值切片，其中獲取包括low_index，不包括high_index，high_index不能大於數組長度

使用案例以下

package main

import "fmt"

func main() {
    var arr1 = [5]int{1, 2, 3, 4, 5}
    var s1 = arr1[2:3]
    var s2 = arr1[:3]
    var s3 = arr1[2:]
    var s4 = arr1[:]
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
}

運行結果以下

3）、切片長度可變性，使用append函數

package main

import "fmt"

func main() {
    var arr1 = make([]int, 5, 10)
    for i := 0; i < len(arr1); i++ {
        arr1[i] = i
    }
    fmt.Println(arr1)

    arr1 = append(arr1, 5, 6, 7, 8, 9, 10)
    fmt.Println("Capacity:", cap(arr1), "Length:", len(arr1))
    fmt.Println(arr1)
}

運行結果如圖，可知切片擴容算法是原來容量大小的兩倍；在測試代碼中發現，若是追加元素超過兩倍容量，後面擴容算法就不會是倍數擴容了

4）、copy函數，複製切片中元素

package main

import "fmt"

func main() {
    slice1 := []int{1, 2, 3, 4, 5, 6}
    slice2 := make([]int, 5, 10)
    copy(slice2, slice1)
    fmt.Println(slice1)
    fmt.Println(slice2)
}

運行結果以下，slice2長度爲5，因此只拷貝了slice1的前五個元素

5）、小總結一下，使用 := 方式定義切片，和數組區別僅僅是方括號[]中是否有數字或 ...

示例以下，輸出結果都是：[1 2 3 4]

package main

import "fmt"

func main() {
    arr1 := [4]int{1, 2, 3, 4}
    fmt.Println(arr1)
    arr2 := [...]int{1, 2, 3, 4}
    fmt.Println(arr2)
    arr3 := []int{1, 2, 3, 4}
    fmt.Println(arr3)
}

三、字典（Map）

 字典是一組無序的，鍵值對的集合，字典也叫關聯數組，數組經過索引取數，字典經過鍵來取數

1）、初始化數據方式定義字典

package main

import "fmt"

func main() {
    var x = map[string]string{
        "A": "Apple",
        "B": "Banana",
        "O": "Orange",
        "P": "Pear",
    }

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

運行結果

 2）、make函數定義map，若是隻定義，不初始化，使用會報錯

package main

import "fmt"

func main() {
    var x map[string]string  //定義map
    x = make(map[string]string)  //初始化map

    x["A"] = "Apple"
    x["B"] = "Banana"
    x["O"] = "Orange"
    x["P"] = "Peer"

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

3）、使用 := 定義並初始化map

package main

import "fmt"

func main() {
    x := make(map[string]string)

    x["A"] = "Apple"
    x["B"] = "Banana"
    x["O"] = "Orange"
    x["P"] = "Peer"

    for key, val := range x {
        fmt.Println("Key:", key, "Value:", val)
    }
}

4）、獲取字典中不存在的key值，若是是整數則返回0，字符串返回 ""；這樣的返回值，若是map中就是有值爲0或空字符串，就沒法區分了

使用 := 能夠獲取map中元素值和是否存在的布爾類型，以下

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    val1, ok1 := x["C"]
    fmt.Println(val1)
    fmt.Println(ok1)

    val2, ok2 := x["A"]
    fmt.Println(val2)
    fmt.Println(ok2)
}

運行結果

在實際使用中，能夠以下判斷是否含有key值

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    if val, ok := x["C"]; ok {
        fmt.Println(val)
    }else{
        fmt.Println("不存在")
    }
}

輸出以下

5）、map中使用delete函數刪除元素，若是不存在，刪除也不會報錯，不會有任何其餘影響

package main

import "fmt"

func main() {
    x := make(map[string]int)

    x["A"] = 0
    x["B"] = 1

    fmt.Println("Before Delete:")
    fmt.Println("Length:", len(x))
    fmt.Println(x)

    delete(x, "A")

    fmt.Println("After Delete:")
    fmt.Println("Length:", len(x))
    fmt.Println(x)
}

運行結果

6）、map複雜案例一：

package main

import "fmt"

func main() {
    var facebook = make(map[string]map[string]int)

    //注意下面對map賦值，不要對{}回車換行
    facebook["2018001"] = map[string]int{"Jemy": 25}
    facebook["2018002"] = map[string]int{"Andy": 23}
    facebook["2018003"] = map[string]int{"Bill": 22}

    for stu_no, stu_info := range facebook {
        fmt.Println("Student:", stu_no)
        for name, age := range stu_info {
            fmt.Println("Name:", name, "Age:", age)
        }
        fmt.Println()
    }
}

輸出結果

map複雜案例二（執行結果和上面同樣）

package main

import "fmt"

func main() {
    var facebook = map[string]map[string]int{
        "2018001": {"Jemy": 25},
        "2018002": {"Andy": 23},
        "2018003": {"Bill": 22},
    }

    for stu_no, stu_info := range facebook {
        fmt.Println("Student:", stu_no)
        for name, age := range stu_info {
            fmt.Println("Name:", name, "Age:", age)
        }
        fmt.Println()
    }
}