1 简介

map 本身是 无序的，也就是说，Go 不保证遍历 map 时的顺序，因此无法直接对 map 的键进行排序并输出。

本文通过一些技巧间接实现排序，或者使用其他数据结构来保持排序。

2 如何对 map 的键进行排序并输出

首先，我们需要将 map 的键提取到一个切片中，然后对这个切片进行排序。排序后的键可以用来访问 map 中的值。

示例：对 map 的键排序并输出

假设我们有一个 map 类型，键是字符串，值是整数，我们想按键的字典顺序输出 map 中的键值对。

    import (
        "fmt"
        "sort"
    )

    func main() {
        // 创建一个 map
        m := map[string]int{
            "banana": 2,
            "apple":  5,
            "pear":   1,
            "orange": 3,
        }

        // 将 map 的键提取到切片中
        var keys []string
        for k := range m {
            keys = append(keys, k)
        }

        // 对键进行排序
        sort.Strings(keys)

        // 按照排序后的键输出 map 中的键值对
        for _, k := range keys {
            fmt.Println(k, m[k])
        }
    }

2. 输出结果

    apple 5
    banana 2
    orange 3
    pear 1
   

在上面的代码中，我们首先将 map 的所有键提取到一个切片中，然后用 sort.Strings 对切片进行排序。之后，我们遍历排序后的键，按顺序输出每个键对应的值。

3. 使 map 保持排序稳定输出和保存

Go 语言中的 map 数据结构本身不支持排序，因为它是一个无序的哈希表。因此，map 无法直接保持某种排序。为了保持排序的输出顺序，我们需要使用以下方法：

• 方法 1：使用 slice 按需排序

如果你需要排序后的顺序在每次输出时保持一致，你可以使用一个切片来保存排序后的键或键值对，并通过该切片来访问数据。

示例：使用切片保存排序后的键值对

    import (
        "fmt"
        "sort"
    )

    type Item struct {
        Key   string
        Value int
    }

    func main() {
        m := map[string]int{
            "banana": 2,
            "apple":  5,
            "pear":   1,
            "orange": 3,
        }

        // 将 map 转换成切片
        var items []Item
        for k, v := range m {
            items = append(items, Item{Key: k, Value: v})
        }

        // 按照 Key 排序
        sort.Slice(items, func(i, j int) bool {
            return items[i].Key < items[j].Key
        })

        // 输出排序后的切片
        for _, item := range items {
            fmt.Println(item.Key, item.Value)
        }
    }

结果：

  apple 5
  banana 2
  orange 3
  pear 1

这里我们通过一个结构体 Item 来封装 map 中的键值对，并将它们转换成切片。通过对切片进行排序，我们能够控制排序方式并保持排序稳定。

• 方法 2：使用 OrderedMap（第三方库）

如果你需要一个可以保持排序的 map，可以使用第三方库 github.com/elliotchance/orderedmap，这个库实现了一个 有序的 map，它可以在插入元素时保持顺序。

安装：

		go get github.com/elliotchance/orderedmap

示例：

      import (
          "fmt"
          "github.com/elliotchance/orderedmap"
      )

      func main() {
          // 创建一个有序 map
          m := orderedmap.New()

          // 插入数据
          m.Set("banana", 2)
          m.Set("apple", 5)
          m.Set("pear", 1)
          m.Set("orange", 3)

          // 输出时保持插入顺序
          m.VisitAll(func(k string, v interface{}) {
              fmt.Println(k, v)
          })
      }

结果

  banana 2
  apple 5
  pear 1
  orange 3

在这个例子中，我们使用了 orderedmap.New() 创建了一个有序的 map，它保持了插入顺序。在输出时，元素的顺序与插入时的顺序一致。

4 小结：

Go 的原生 map 不保证顺序，因此不能直接对 map 进行排序。

方法 1：通过将 map 的键提取到切片并排序来间接实现排序输出。

方法 2：使用第三方库 orderedmap，它提供了一个可以保持插入顺序的有序 map。

如果需要频繁排序和稳定输出，使用 切片 或 OrderedMap 是较好的选择。

希望这些示例能够帮助你理解如何在 Go 中对 map 进行排序，并根据需求保持某种排序稳定性