这是一个非常常见且重要的问题。Java 的 Map 本身不保证其键的任何特定顺序，你可以通过使用特定的 Map 实现类来获得排序的键。

下面我们来详细分解这个问题。

核心结论：Map 接口不保证顺序

Map 接口本身的设计目标是无序的（或更准确地说是“不保证顺序”），这意味着如果你遍历一个普通的 Map，其元素的顺序可能是插入顺序、哈希顺序，甚至是看似随机的,具体取决于其底层实现。

常见的 Map 实现类及其顺序特性：

如何获得排序的键？

如果你需要一个键是排序的 Map，你有两种主要选择：TreeMap 或 LinkedHashMap（用于插入顺序），对于排序，TreeMap 是最直接和最常用的选择。

使用 TreeMap（推荐）

TreeMap 会根据其键的自然顺序（如果键实现了 Comparable 接口）或者你在创建 TreeMap 时提供的 Comparator 对键进行排序。

示例 1：键的自然顺序

如果键是基本类型（如 Integer, String）或者你自定义的类实现了 Comparable 接口，TreeMap 会自动排序。

import java.util.Map;
import java.util.TreeMap;
public class TreeMapNaturalOrder {
    public static void main(String[] args) {
        // Map 的键是 String，String 实现了 Comparable 接口
        Map<String, Integer> map = new TreeMap<>();
        map.put("banana", 3);
        map.put("apple", 1);
        map.put("orange", 2);
        map.put("grape", 4);
        // 遍历 Map，键会按字母顺序排序
        System.out.println("按键的自然顺序排序:");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        // 输出:
        // apple : 1
        // banana : 3
        // grape : 4
        // orange : 2
    }
}

示例 2：使用自定义 Comparator

如果键没有实现 Comparable，或者你想用不同于自然顺序的方式排序，可以提供一个 Comparator。

import java.util.*;
import java.util.stream.Collectors;
public class TreeMapCustomOrder {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(3, "Charlie");
        map.put(1, "Alice");
        map.put(4, "David");
        map.put(2, "Bob");
        // 使用 TreeMap 和自定义 Comparator 按键的降序排序
        Map<Integer, String> sortedMap = new TreeMap<>(Comparator.reverseOrder());
        sortedMap.putAll(map);
        System.out.println("按键的降序排序:");
        for (Map.Entry<Integer, String> entry : sortedMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        // 输出:
        // 4 : David
        // 3 : Charlie
        // 2 : Bob
        // 1 : Alice
    }
}

使用 LinkedHashMap（用于插入顺序）

LinkedHashMap 保证的是插入顺序，而不是排序，它通过维护一个双向链表来记录元素的插入顺序，如果你只是想按照你添加元素的顺序来访问它们，而不是按字母或数字大小排序，LinkedHashMap 是正确的选择。

import java.util.LinkedHashMap;
import java.util.Map;
public class LinkedHashMapOrder {
    public static void main(String[] args) {
        Map<String, Integer> map = new LinkedHashMap<>();
        map.put("banana", 3);
        map.put("apple", 1);
        map.put("orange", 2);
        System.out.println("按插入顺序遍历:");
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
        // 输出:
        // banana : 3
        // apple : 1
        // orange : 2
    }
}

如何对现有 Map 的键进行排序？

如果你已经有了一个 HashMap 并且希望在不改变其原始结构的情况下，获取一个按排序后的键视图，最现代、最简洁的方法是使用 Java 8 的 Stream API。

import java.util.*;
import java.util.stream.Collectors;
public class SortMapKeys {
    public static void main(String[] args) {
        // 1. 创建一个普通的、无序的 HashMap
        Map<String, Integer> scores = new HashMap<>();
        scores.put("David", 95);
        scores.put("Charlie", 88);
        scores.put("Alice", 92);
        scores.put("Bob", 85);
        System.out.println("原始 HashMap (顺序不确定): " + scores);
        // 2. 使用 Stream API 对键进行排序，并收集到一个新的 LinkedHashMap 中
        //    (LinkedHashMap 用于保持排序后的顺序)
        Map<String, Integer> sortedScores = scores.entrySet()
                .stream()
                // 按键的自然顺序排序
                .sorted(Map.Entry.comparingByKey())
                // 收集到一个新的 LinkedHashMap 中
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (oldValue, newValue) -> oldValue, // 合并函数，对于键冲突时使用
                        LinkedHashMap::new                 // 指定目标 Map 的实现类
                ));
        System.out.println("按键排序后的 LinkedHashMap:");
        sortedScores.forEach((k, v) -> System.out.println(k + " : " + v));
        // 输出:
        // 原始 HashMap (顺序不确定): {Charlie=88, Alice=92, Bob=85, David=95}
        // 按键排序后的 LinkedHashMap:
        // Alice : 92
        // Bob : 85
        // Charlie : 88
        // David : 95
    }
}

Map 接口本身是无序的，是具体的实现类（如 HashMap, TreeMap, LinkedHashMap）决定了其行为。