GO语言基础-04-数据类型-04-map（map的排序）

1. 按value排序

1.1 思路

• map本身的顺序不可控，我们考虑如下方法实现排队：
  • 思路一：通过一个切片来接收拍好队的map成员
  • 思路二：用一个切片接收map成员，给切片排队
• 我们找到sort.Slice()方法轻松给切片排队，因此决定使用思路二

1.2 语法

• 语法

func Slice(x any, less func(i int, j int) bool)

参数中的函数自定义一个比较的方法

• 语法示例

	sort.Slice(mySlice, func(i, j int) bool {
    
    
		return mySlice[i].Weight < mySlice[j].Weight
	})

1.3 完整示例

package main

import (
	"fmt"
	"sort"
)

//创建一个切片准备接收map的数据
type Fruit struct {
    
    
	Name   string
	Weight int64
}

func main() {
    
    
    //实例化一个map
	fruitMap := map[string]int64{
    
    
		"banana": 7,
		"apple":  5,
		"orange": 6,
		"peach":  8,
		"lemon":  9,
	}

    //创建一个接收结构体的切片，将map的值传入切片
	var fruitList []Fruit
	for k, v := range fruitMap {
    
    
		fruitList = append(fruitList, Fruit{
    
    k, v})
	}
	fmt.Printf("排序前：%+v\n", fruitList)

    //给切片排序
	sort.Slice(fruitList, func(i, j int) bool {
    
    
		return fruitList[i].Weight < fruitList[j].Weight
	})
	fmt.Printf("排序后：%+v\n", fruitList)
}

• 输出结果

排序前：[{
    
    Name:peach Weight:8} {
    
    Name:lemon Weight:9} {
    
    Name:banana Weight:7} {
    
    Name:apple Weight:5} {
    
    Name:orange Weight:6}]
排序后：[{
    
    Name:apple Weight:5} {
    
    Name:orange Weight:6} {
    
    Name:banana Weight:7} {
    
    Name:peach Weight:8} {
    
    Name:lemon Weight:9}]

如上可见，接收切片fruitList 排序前是乱的（因为map的顺序不可控），排序后可以按大小输出了

2. 按key排序

2.1 思路

• 用一个切片接收map的key
• 给切片成员排序
• 按切片输出map成员

2.2 语法示例

func Sort(data Interface)

2.3 完整示例

• 代码

package main

import (
	"fmt"
	"sort"
)

func main() {
    
    
	//定义一个map
	MyMap := map[int]int64{
    
    
		3: 7,
		2: 5,
		4: 6,
		7: 8,
		6: 9,
	}
	//定义一个切片组，接收map的key
	keys := []int{
    
    }
	for key := range MyMap {
    
    
		keys = append(keys, key)
	}
	//给切片排序
	sort.Sort(sort.IntSlice(keys))
   //按着切片输出map（当然你也可以用另一个切片接收）
	for _, key := range keys {
    
    
		fmt.Printf("%v : %v\n", key, MyMap[key])
	}
}

• 输出

2 : 5
3 : 7
4 : 6
6 : 9
7 : 8

2.4 完整示例

当然，我们按着 1.3中的方法直接用切片来接收并排序也是可以的

• 代码

package main

import (
	"fmt"
	"sort"
)

// 创建一个切片准备接收map的数据
type Fruit struct {
    
    
	Key   int
	Value int64
}

func main() {
    
    
	//实例化一个map
	fruitMap := map[int]int64{
    
    
		3: 7,
		2: 5,
		4: 6,
		7: 8,
		6: 9,
	}

	//创建一个接收结构体的切片，将map的值传入切片
	var fruitList []Fruit
	for k, v := range fruitMap {
    
    
		fruitList = append(fruitList, Fruit{
    
    k, v})
	}
	fmt.Printf("排序前：%+v\n", fruitList)

	//给切片排序
	sort.Slice(fruitList, func(i, j int) bool {
    
    
		return fruitList[i].Key < fruitList[j].Key
	})
	fmt.Printf("排序后：%+v\n", fruitList)
}

• 输出

排序前：[{
    
    Key:3 Value:7} {
    
    Key:2 Value:5} {
    
    Key:4 Value:6} {
    
    Key:7 Value:8} {
    
    Key:6 Value:9}]
排序后：[{
    
    Key:2 Value:5} {
    
    Key:3 Value:7} {
    
    Key:4 Value:6} {
    
    Key:6 Value:9} {
    
    Key:7 Value:8}]

---