我有一个Map，它的键和值都是字符串。
数据如下：
"question1", "1"
"question9", "1"
"question2", "4"
"question5", "2"
我想按照Map的键对其进行排序。因此，最终我将获得question1，question2，question3等。
最终，我要从这个Map中获取两个字符串：
现在我有以下内容：
Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
questionAnswers += pairs.getKey() + ",";
}
使用TreeMap。这正是它的用途。
如果这个映射被传递给您，而您无法确定类型，则可以执行以下操作：
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有额外的构造函数，让您传递一个Comparator：
// 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个项目增加到10000个项目并不会影响查找元素的时间，但对于 TreeMap 来说，查找时间会变慢约1.3倍（假设Log 2）。 将1000个元素移动到100,000将使每个元素查找变慢约1.6倍。假设TreeMap不适合您（并且假设您无法使用泛型）：
List sortedKeys=new ArrayList(yourMap.keySet());
Collections.sort(sortedKeys);
// Do what you need with sortedKeys.
使用 TreeMap 可以对 Map 进行排序。
Map<String, String> map = new HashMap<>();
Map<String, String> treeMap = new TreeMap<>(map);
for (String str : treeMap.keySet()) {
System.out.println(str);
}
只需使用TreeMap：
new TreeMap<String, String>(unsortMap);
请注意，TreeMap按其“键”的自然顺序排序。
如果您已经有一张地图并且想按键进行排序，只需使用：
Map<String, String> treeMap = new TreeMap<String, String>(yourMap);
一个完整的工作示例：
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
class SortOnKey {
public static void main(String[] args) {
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("3", "three");
hm.put("1", "one");
hm.put("4", "four");
hm.put("2", "two");
printMap(hm);
Map<String, String> treeMap = new TreeMap<String, String>(hm);
printMap(treeMap);
} // main
public static void printMap(Map<String, String> map) {
Set s = map.entrySet();
Iterator it = s.iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println(key + " => " + value);
} // while
System.out.println("========================");
} // printMap
} // class
如果您不能使用 TreeMap，在 Java 8 中我们可以使用 Collectors 中的toMap() 方法，该方法接受以下参数：
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));
使用Java 8：
Map<String, Integer> sortedMap = unsortMap.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
(oldValue, newValue) -> oldValue, LinkedHashMap::new));
按键对Map<K，V>进行排序，将键放入List<K>：
List<K> result = map.keySet().stream().sorted().collect(Collectors.toList());
对于一个 Map<K, V> 按照键进行排序，并将其放入一个 List<Map.Entry<K, V>> 中：
List<Map.Entry<K, V>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey())
.collect(Collectors.toList());
最后但并非最不重要的: 要以区域敏感方式排序字符串，请使用Collator (比较器) 类：
Collator collator = Collator.getInstance(Locale.US);
collator.setStrength(Collator.PRIMARY); // case insensitive collator
List<Map.Entry<String, String>> result =
map.entrySet()
.stream()
.sorted(Map.Entry.comparingByKey(collator))
.collect(Collectors.toList());
这段代码可以按升序和降序排序键-值映射。
<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