Go语言map排序（key/value排序）

1、前言

Go语言的map是无序的，多次遍历map的结果可能是不同的，比如：

package main

import (
    "fmt"
)

func Map() (result map[int]uint32) {
    result = map[int]uint32{}
    // 插入各个数据
    result[24] = 240
    result[17] = 170
    result[9] = 90
    result[11] = 110
    result[55] = 550
    return
}
func main() {
    mapResult := Map()
    // 遍历map
    for key, value := range mapResult {
        fmt.Printf("key = %v,value = %v\n", key, value)
    }
}

第一次遍历结果如下：

第二次遍历结果如下：

可以看到两次遍历的结果是不同的

2、实现map遍历有序

2.1 key有序

思路：对key排序，再遍历key输出value

2.1.1 从小到大排序

sort.Sort(sort.IntSlice(keys))

代码如下：

package main

import (
    "fmt"
    "sort"
)

func Map() (result map[int]uint32, keys []int) {
    result = map[int]uint32{}
    keys = []int{}
    // 插入各个数据
    result[24] = 240
    result[17] = 170
    result[9] = 90
    result[11] = 110
    result[55] = 550
    // 得到各个key
    for key := range result {
        keys = append(keys, key)
    }
    // 给key排序，从小到大
    sort.Sort(sort.IntSlice(keys))
    return
}
func main() {
    mapResult, keys := Map()
    // 遍历map
    for _, key := range keys {
        fmt.Printf("key = %v,value = %v\n", key, mapResult[key])
    }
}

结果：

2.1.2 从大到小排序

sort.Sort(sort.Reverse(sort.IntSlice(keys)))

代码如下：

package main

import (
    "fmt"
    "sort"
)

func Map() (result map[int]uint32, keys []int) {
    result = map[int]uint32{}
    keys = []int{}
    // 插入各个数据
    result[24] = 240
    result[17] = 170
    result[9] = 90
    result[11] = 110
    result[55] = 550
    // 得到各个key
    for key := range result {
        keys = append(keys, key)
    }
    // 给key排序，从大到小
    sort.Sort(sort.Reverse(sort.IntSlice(keys)))
    return
}
func main() {
    mapResult, keys := Map()
    // 遍历map
    for _, key := range keys {
        fmt.Printf("key = %v,value = %v\n", key, mapResult[key])
    }
}

结果：

2.2 value有序

用struct存放key和value，实现sort接口，就可以调用sort.Sort进行排序了

2.2.1 从小到大排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    mapInfo := map[string]int32{
        "roy":18,
        "kitty":16,
        "hugo":21,
        "tina":35,
        "jason":23,
    }

    type peroson struct {
        Name string
        Age int32
    }

    var lstPerson []peroson
    for k, v := range mapInfo {
        lstPerson = append(lstPerson, peroson {k, v})
    }

    sort.Slice(lstPerson, func(i, j int) bool {
        return lstPerson[i].Age < lstPerson[j].Age  // 升序
    })
    fmt.Println(lstPerson)
}

结果：

2.2.2 从大到小排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    mapInfo := map[string]int32{
        "roy":   18,
        "kitty": 16,
        "hugo":  21,
        "tina":  35,
        "jason": 23,
    }

    type peroson struct {
        Name string
        Age  int32
    }

    var lstPerson []peroson
    for k, v := range mapInfo {
        lstPerson = append(lstPerson, peroson{k, v})
    }

    sort.Slice(lstPerson, func(i, j int) bool {
        return lstPerson[i].Age > lstPerson[j].Age // 降序
    })
    fmt.Println(lstPerson)
}

结果：