这里提供了一个很好的解决方案。我们有一个HashMap，它以未指定的顺序存储值。我们定义了一个辅助TreeMap，并使用putAll方法将所有数据从HashMap复制到TreeMap中。TreeMap中的结果条目按键顺序排列。

使用LinkedHashMap，它提供了密钥排序。它的性能也和HashMap一样。它们都实现了Map接口，所以你可以将初始化对象HashMap替换为LinkedHashMap。

这段代码可以对键值映射进行两种排序，即升序和降序。

<K, V extends Comparable<V>> Map<K, V> sortByValues
     (final Map<K, V> map, int ascending)
{
     Comparator<K> valueComparator =  new Comparator<K>() {
        private int ascending;
        public int compare(K k1, K k2) {
            int compare = map.get(k2).compareTo(map.get(k1));
            if (compare == 0)
                return 1;
            else
                return ascending*compare;
        }
        public Comparator<K> setParam(int ascending)
        {
              this.ascending = ascending;
              return this;
        }
    }.setParam(ascending);

    Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
    sortedByValues.putAll(map);
    return sortedByValues;
}

举个例子:

Map<Integer, Double> recommWarrVals = new HashMap<Integer, Double>();
recommWarrVals = sortByValues(recommWarrVals, 1);  // Ascending order
recommWarrVals = sortByValues(recommWarrVals, -1);  // Descending order

如果你不能使用TreeMap，在Java 8中，我们可以使用collector中的toMap()方法，该方法接受以下参数:

Keymapper:生成密钥的映射功能 Valuemapper:生成值的映射函数 mergeFunction:一个归并函数，用于解决与相同键相关联的值之间的冲突 mapSupplier:返回一个新的空Map的函数 结果将被插入。

Java 8实例

Map<String, String> sample = new HashMap<>(); // Push some values to map
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                    .sorted(Map.Entry.<String, String>comparingByKey().reversed())
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
                        .sorted(Map.Entry.<String, String>comparingByValue().reversed())
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

我们可以修改这个例子，使用自定义比较器，并根据键进行排序:

Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                .sorted((e1, e2) -> e1.getKey().compareTo(e2.getKey()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

简短的回答

使用树地图。这正是它的用途。

如果此映射传递给您，而您无法确定类型，那么您可以执行以下操作:

SortedSet<String> keys = new TreeSet<>(map.keySet());
for (String key : keys) { 
   String value = map.get(key);
   // do something
}

这将以键的自然顺序遍历整个地图。

再回答

从技术上讲，您可以使用实现SortedMap的任何东西，但除了极少数情况外，这相当于TreeMap，就像使用Map实现通常相当于HashMap一样。

如果你的键是一个复杂类型，没有实现Comparable，或者你不想使用自然顺序，那么TreeMap和TreeSet有额外的构造函数，让你传递一个比较器:

// placed inline for the demonstration, but doesn't have to be a lambda expression
Comparator<Foo> comparator = (Foo o1, Foo o2) -> {
        ...
    }

SortedSet<Foo> keys = new TreeSet<>(comparator);
keys.addAll(map.keySet());

请记住，在使用TreeMap或TreeSet时，它将具有与HashMap或HashSet不同的性能特征。粗略地说，查找或插入元素的操作将从O(1)到O(Log(N))。

在HashMap中，从1000个条目移动到10,000个条目并不会真正影响查找元素的时间，但对于TreeMap，查找时间将慢1.3倍(假设Log2)。从1000到100,000的每一个元素查找速度都要慢1.6倍。

使用树地图!