数组，切片和字典

1、数组（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",//可以带着英文逗号
　　　　　　　　　　　　}　　　　　　　　　　　　　　　　　　　　　　　　}

2、切片（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)
}

3、字典（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()
    }
}