【原创】go语言学习，十Map类型

目录

• 声明和初始化
• 基本操作
• map排序
• map类型的切⽚片
• 课后作业

声明和初始化

1、map类型是⼀一个key-value的数据结构。

//var a map[key的类型]value类型
var a map[string]int
var b map[int]string
var c map[float32]string

　　注意：map必须初始化才能使⽤用，否则panic

2、map类型的变量量默认初始化为nil，需要使⽤用make分配map内存

package main
import (
    "fmt"
)
func main() {
    var a map[string]int
    if a == nil {
        fmt.Println("map is nil. Going to make one.")
        A = make(map[string]int)
    }
}

基本操作

1、map插入操作

package main
import (
    "fmt"
)
func main() {
    a := make(map[string]int)
    a["steve"] = 12000
    a["jamie"] = 15000
    a["mike"] = 9000
    fmt.Println(“a map contents:", a)
}

2、声明时进⾏行行初始化

package main
import (
    "fmt"
)
func main() {
    var a map[string]int
    if a == nil {
        fmt.Println("map is nil. Going to make one.")
        A = make(map[string]int)
    }
}        

3、map插入操作

package main
import (
    "fmt"
)
func main() {
    a := make(map[string]int)
    a["steve"] = 12000
    a["jamie"] = 15000
    a["mike"] = 9000
    fmt.Println(“a map contents:", a)
}

4、声明时进⾏行行初始化

package main
import (
    "fmt"
)
func main() {
    a := map[string]int {
        "steve": 12000,
        "jamie": 15000,
    }
    a[“mike"] = 9000
    fmt.Println(“a map contents:", a)
}

5、 通过key访问map中的元素

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    b := "jamie"
    fmt.Println("Salary of", b, "is", a[b])
}

6、 通过key访问map中的元素

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    b := “123”
    fmt.Println("Salary of", b, "is", a[b])
}

7、如何判断map指定的key是否存在? value, ok := map[key]

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    b := "joe"
    value, ok := a[b]
    if ok == true {
        fmt.Println("Salary of", b, "is", value)
    } else {
        fmt.Println(b,”not found")
    }
}        

8、map遍历操作

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    fmt.Println("All items of a map")
    for key, value := range a {
        fmt.Printf("personSalary[%s] = %d\n", key, value)
    }
}        

9、map删除元素

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    fmt.Println("map before deletion", a)
    delete(a, "steve")
    fmt.Println("map after deletion", a)
}

10、map的长度

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    fmt.Println("length is", len(a))
}

11、map是引用类型

package main
import (
    "fmt"
)
func main() {
    a := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    a["mike"] = 9000
    fmt.Println(“origin map", a)
    b := a
    b["mike"] = 18000
    fmt.Println(“a map changed", a)
}

12、map按照key进行行排序，遍历

package main
import (
    "fmt"
    "sort"
)
func main() {
    var a map[string]int = make(map[string]int, 10)
    for i := 0; i < 10; i++ {
        key := fmt.Sprintf("key%d", i)
        a[key] = i
    }
    var keys []string
    for key, _ := range a {
        keys = append(keys, key)
    }
    sort.Strings(keys)
    for _, key := range keys {
        fmt.Printf("key:%s=%d\n", key, a[key])
    }
}    

map排序

package main

import (
        "fmt"
        "math/rand"
        "sort"
        "time"
)

func main() {
        rand.Seed(time.Now().UnixNano())
        var a map[string]int = make(map[string]int, 1024)

        for i := 0; i < 128; i++ {
                key := fmt.Sprintf("stu%d", i)
                value := rand.Intn(1000)
                a[key] = value
        }

        var keys []string = make([]string, 0, 128)
        for key, value := range a {
                fmt.Printf("map[%s]=%d\n", key, value)
                keys = append(keys, key)
        }

        sort.Strings(keys)
        for _, value := range keys {
                fmt.Printf("key:%s val:%d\n", value, a[value])
        }
}

map类型的切片

package main

import (
        "fmt"
        "math/rand"
        "time"
)

func sliceMap(){
        rand.Seed(time.Now().UnixNano())
        var s[]map[string] int
        s = make([]map[string]int, 5, 16)
        for index,val := range s {
                fmt.Printf("slice[%d]=%v\n", index, val)
        }

        fmt.Println()
        s[0] = make(map[string]int, 16)
        s[0]["stu01"] = 1000
        s[0]["stu02"] = 1000
        s[0]["stu03"] = 1000

        for index, val := range s {
                fmt.Printf("slice[%d]=%v\n", index, val)
        }
}

func mapSlice() {
        rand.Seed(time.Now().UnixNano())
        var s map[string][]int
        s = make(map[string[]int, 16)
        key := "stu01"
        value, ok := s[key]
        if !ok {
                s[key] = make([]int, 0, 16)

                value  = s[key]
        }


        value = append(value, 100)
        value = append(value, 200)
        value = append(value, 300)

        s[key] = value
        fmt.Printf("map:%v\n", s)
}

func main(){
        //sliceMap()
}