golang之数组，slice，map

一 、==========================array 数组===================================

    索引只能是 int 整数型 所以不管几维数组 索引都是 整数  slice 是动态数组 索引也是 整数型 map为key 所以 可以为 整数 也可以为 字符串型

    注意slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

arr1 := [10]int{1,2,3,4} //数组,长度为10,只有4个元素指定,其它的元素值默认为0

arr2 := [...]string{"a","b","c"} //数组,长度自适应,这里长度为3

s1 := []int{1,2,3,4} //slice,目前长度为4,可能通过append来动态添加元素个数

数组声明 方式

arr1 := [10]int{1,2,3,4} //数组,长度为10,只有4个元素指定,其它的元素值默认为0

里面索引为 0:1  1:2  2:3  3:4  4:0  5:0  .....  9:0

arr1 := [10]string{"1","2","3","4"} //数组,长度为10,只有4个元素指定,其它的元素值默认为"" 空字符串

里面索引为 0:"1"  1:"2"  2:"3"  3:"4"  4:"0"  5:""  .....  9:""

arr2 := [...]string{"a","b","c"} //数组,长度自适应,这里长度为3

arr3 := make([]int, 10)  // make 为创建内存  长度为10  元素都为 0

var arr4 [5]int

arr4[0] = 9

arr4=[5]int{5,5,5}  // [5 5 5 0 0]

可以用 new() 创建数组，返回数组指针。

func test(a *[10]int) {

    a[2] = 100   // 用指针直接操作没有压力。

}

func main() {

    var a = new([10]int)   // 返回指针。

    test(a)

    fmt.Println(a, len(a))

}

输出结果：

&[0 0 100 0 0 0 0 0 0 0] 10

多维数组 

a := [2][2]int{ {1,2}, {3,4} }

b := [2][2]str{ {"1","2"}, {"3","4"} }

func main() {

    var a = [3][2]int{ [...]int{1, 2}, [...]int{3, 4} }

    var b = [3][2]int{ {1, 2}, {3, 4} }

    c := [...][2]int{ {1, 2}, {3, 4}, {5, 6} }   // 第二个维度不能用 "..." 。

    c[1][1] = 100

    fmt.Println(a, "\n", b, "\n", c, len(c), len(c[0]))

}

数组比较

println([1]string{"a"} == [1]string{"a"})

数组是值类型，也就是说会拷贝整个数组内存进行值传递。可用 slice 或指针代替。

二 、 ==========================slice 切片===================================

    切片就是数组取其中的部分就为切片为取出的数组数值的指针集合。

    数组  索引只能是 int 整数型 所以不管几维数组 索引都是 整数  slice 是动态数组 索引也是 整数型 map为key 所以 可以为 整数 也可以为 字符串型

    注意slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。

切片声明

s := []int{ 0, 1, 2 }

不能使用 new()，而应该是 make([]T, len, cap)。因为除了分配内存，还需要设置相关的属性。如

果忽略 cap 参数，则 cap = len 。

func main() {

    s1 := make([]int, 10)  // 相当于 [10]int{...}[:]

    s1[1] = 100

    fmt.Println(s1, len(s1), cap(s1))

    s2 := make([]int, 5, 10)

    s2[4] = 200

    fmt.Println(s2, len(s2), cap(s2))

}

输出:

[0 100 0 0 0 0 0 0 0 0] 10 10

[0 0 0 0 200] 5 10

可以用 append() 向 slice 尾部添加新元素，这些元素保存到底层数组。append 并不会影响原 slice的属性，它返回变更后新的 slice 对象。如果超出 cap 限制，则会重新分配底层数组。

==========================Maps 字典===================================

引用类型，类似 Python dict ，不保证 Key/Value 存放顺序。Key 必须是支持比较运算符 (== 、!=)的类型。如 number 、string 、pointer、array、struct 、interface (接口实现类型必须支持比较运算符)，不能是 function、map、slice。

map 查找操作比线性搜索快很多，但比起用序号访问 array、slice，大约慢 100x 左右。绝大多数时候，其操作性能要略好于 Python Dict 、C++ Map。

func test(d map[string]int) {

    d["x"] = 100

}

func main() {

    var d = map[string]int{ "a":1, "b":2 };

    d2 := map[int]string{ 1:"a", 2:"b" };

    test(d)

    fmt.Println(d, d2)

    d3 := make(map[string]string)

    d3["name"] = "Jack"

    fmt.Println(d3, len(d3))

}

输出:

map[a:1 b:2 x:100] map[1:a 2:b]

map[name:Jack] 1

使 array/struct key 的例子。

type User struct {

    Name string

}

func main() {

    a := [2]int{ 0, 1}

    b := [2]int{ 0, 1}

    d := map[[2]int]string { a: "ssss" }

    fmt.Println(d, d[b])

    u := User{ "User1" }

    u2 := u

    d2 := map[User]string { u: "xxxx" }

    fmt.Println(d2, d2[u2])

}

输出:

map[[0 1]:ssss] ssss

map[{User1}:xxxx] xxxx

value 的类型就很自由了，完全可以用匿名结构或者空接口。

type User struct {

    Name string

}

func main() {

    i := 100

    d := map[*int]struct{ x, y float64 } { &i: { 1.0, 2.0 } }

    fmt.Println(d, d[&i], d[&i].y)

    //d2 := map[interface{}]string { "a": "1", 1:"ssssss" }

    d2 := map[string]interface{} { "a": 1, "b": User{ "user1" } }

    fmt.Println(d2, d2["b"].(User).Name)

}

输出:

map[0x42132018:{1 2}] {1 2} 2

map[a:1 b:{user1}] user1

使用 make() 创建 map 时，提供一个合理的初始容量有助于减少后续新增操作的内存分配次数。在需要时，map 会⾃动扩张容量。

常用的判断和删除操作：

func main() {

    var d = map[string]int{ "a":1, "b":2 };

    v, ok := d["b"]  // key b 存在，v = ["b"], ok = true

    fmt.Println(v, ok)

    v = d["c"]  // key c 不存在，v = 0 (default)

    fmt.Println(v)  // 要判断 key 是否存在，建议用 ok idiom 模式。

    d["c"] = 3   // 添加或修改

    fmt.Println(d)

    delete(d, "c")  // 删除。删除不存在的 key，不会引发错误。

    fmt.Println(d)

}

输出:

2 true

0 false

map[a:1 c:3 b:2]

map[a:1 b:2]

迭代器用法:

The Go 1 .1 hashmap iteration starts at a random bucket. However, it stores up to 8 key/value pairs in a bucket.

And within a bucket, hashmap iteration always returns the values in the same order .

func main() {

    d := map[string]int{ "a":1, "b":2 };

    for k, v := range d {  // 获取 key, value

        println(k, "=", v)

    }

    for k := range d {  // 仅获取 key

        println(k, "=", d[k])

    }

}

通过 map[key] 返回的只是一个 "临时值拷贝"，修改其自身状态没有任何意义，只能重新 value 赋值或改用指针修改所引用的内存。

type User struct {

    Id int

    Name string

}

func main() {

    users := map[string]User{

        "a": User{1, "user1"},

    }

    fmt.Println(users)

    // Error: cannot assign to users["a"].Name

    //users["a"].Name = "Jack"

    // 重新 value 赋值

    u := users["a"]

    u.Name = "Jack"

    users["a"] = u

    fmt.Println(users["a"])

    // 改⽤指针类型

    users2 := map[string]*User{

        "a2": &User{2, "user2"},

    }

    users2["a2"].Name = "Tom"

    fmt.Println(users2["a2"])

}

输出:

map[a:{1 user1}]

{1 Jack}

&{2 Tom}

可以在 for range 迭代时安全删除和插入新的字典项。

func main() {

    d := map[string]int { "b":2, "c":3, "e":5 }

    for k, v := range d {

        println(k, v)

        if k == "b" { delete(d, k) }

        if k == "c" { d["a"] = 1 }

    }

    fmt.Println(d)

}

输出：

c 3

b 2

e 5

map[a:1 c:3 e:5]

注：map 作为参数时，直接复制指针。