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)
}

后果：