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

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

• 1、前言
• 2、实现map遍历有序
• • 2.1 key有序
  • • 2.1.1 从小到大排序
    • 2.1.2 从大到小排序
  • 2.2 value有序
  • • 2.2.1 从小到大排序
    • 2.2.2 从大到小排序

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

结果：